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

Commit 59b2858f57bbd42f36aa177d21ab011a87da3de2

Authored by Linus Torvalds 2015-01-18 02:24:30 +0800

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

Merge branch 'perf-urgent-for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/tip/tip

Pull perf fixes from Ingo Molnar:
 "Mostly tooling fixes, but also two PMU driver fixes"

* 'perf-urgent-for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/tip/tip:
  perf tools powerpc: Use dwfl_report_elf() instead of offline.
  perf tools: Fix segfault for symbol annotation on TUI
  perf test: Fix dwarf unwind using libunwind.
  perf tools: Avoid build splat for syscall numbers with uclibc
  perf tools: Elide strlcpy warning with uclibc
  perf tools: Fix statfs.f_type data type mismatch build error with uclibc
  tools: Remove bitops/hweight usage of bits in tools/perf
  perf machine: Fix __machine__findnew_thread() error path
  perf tools: Fix building error in x86_64 when dwarf unwind is on
  perf probe: Propagate error code when write(2) failed
  perf/x86/intel: Fix bug for "cycles:p" and "cycles:pp" on SLM
  perf/rapl: Fix sysfs_show() initialization for RAPL PMU

Showing 26 changed files Inline Diff

arch/x86/kernel/cpu/perf_event_intel_ds.c
arch/x86/kernel/cpu/perf_event_intel_rapl.c
tools/include/asm-generic/bitops.h
tools/include/asm-generic/bitops/arch_hweight.h
tools/include/asm-generic/bitops/const_hweight.h
tools/include/asm-generic/bitops/hweight.h
tools/include/linux/bitops.h
tools/lib/api/fs/debugfs.c
tools/lib/api/fs/fs.c
tools/perf/MANIFEST
tools/perf/Makefile.perf
tools/perf/arch/powerpc/util/skip-callchain-idx.c
tools/perf/bench/sched-pipe.c
tools/perf/builtin-top.c
tools/perf/config/Makefile
tools/perf/config/Makefile.arch
tools/perf/perf-sys.h
tools/perf/tests/dwarf-unwind.c
tools/perf/util/annotate.h
tools/perf/util/cache.h
tools/perf/util/hweight.c
tools/perf/util/include/asm/hweight.h
tools/perf/util/machine.c
tools/perf/util/probe-event.c
tools/perf/util/python-ext-sources
tools/perf/util/unwind-libunwind.c

arch/x86/kernel/cpu/perf_event_intel_ds.c

Diff comments View file @ 59b2858

1	#include <linux/bitops.h>	1	#include <linux/bitops.h>
2	#include <linux/types.h>	2	#include <linux/types.h>
3	#include <linux/slab.h>	3	#include <linux/slab.h>
4		4
5	#include <asm/perf_event.h>	5	#include <asm/perf_event.h>
6	#include <asm/insn.h>	6	#include <asm/insn.h>
7		7
8	#include "perf_event.h"	8	#include "perf_event.h"
9		9
10	/* The size of a BTS record in bytes: */	10	/* The size of a BTS record in bytes: */
11	#define BTS_RECORD_SIZE 24	11	#define BTS_RECORD_SIZE 24
12		12
13	#define BTS_BUFFER_SIZE (PAGE_SIZE << 4)	13	#define BTS_BUFFER_SIZE (PAGE_SIZE << 4)
14	#define PEBS_BUFFER_SIZE PAGE_SIZE	14	#define PEBS_BUFFER_SIZE PAGE_SIZE
15	#define PEBS_FIXUP_SIZE PAGE_SIZE	15	#define PEBS_FIXUP_SIZE PAGE_SIZE
16		16
17	/*	17	/*
18	* pebs_record_32 for p4 and core not supported	18	* pebs_record_32 for p4 and core not supported
19		19
20	struct pebs_record_32 {	20	struct pebs_record_32 {
21	u32 flags, ip;	21	u32 flags, ip;
22	u32 ax, bc, cx, dx;	22	u32 ax, bc, cx, dx;
23	u32 si, di, bp, sp;	23	u32 si, di, bp, sp;
24	};	24	};
25		25
26	*/	26	*/
27		27
28	union intel_x86_pebs_dse {	28	union intel_x86_pebs_dse {
29	u64 val;	29	u64 val;
30	struct {	30	struct {
31	unsigned int ld_dse:4;	31	unsigned int ld_dse:4;
32	unsigned int ld_stlb_miss:1;	32	unsigned int ld_stlb_miss:1;
33	unsigned int ld_locked:1;	33	unsigned int ld_locked:1;
34	unsigned int ld_reserved:26;	34	unsigned int ld_reserved:26;
35	};	35	};
36	struct {	36	struct {
37	unsigned int st_l1d_hit:1;	37	unsigned int st_l1d_hit:1;
38	unsigned int st_reserved1:3;	38	unsigned int st_reserved1:3;
39	unsigned int st_stlb_miss:1;	39	unsigned int st_stlb_miss:1;
40	unsigned int st_locked:1;	40	unsigned int st_locked:1;
41	unsigned int st_reserved2:26;	41	unsigned int st_reserved2:26;
42	};	42	};
43	};	43	};
44		44
45		45
46	/*	46	/*
47	* Map PEBS Load Latency Data Source encodings to generic	47	* Map PEBS Load Latency Data Source encodings to generic
48	* memory data source information	48	* memory data source information
49	*/	49	*/
50	#define P(a, b) PERF_MEM_S(a, b)	50	#define P(a, b) PERF_MEM_S(a, b)
51	#define OP_LH (P(OP, LOAD) \| P(LVL, HIT))	51	#define OP_LH (P(OP, LOAD) \| P(LVL, HIT))
52	#define SNOOP_NONE_MISS (P(SNOOP, NONE) \| P(SNOOP, MISS))	52	#define SNOOP_NONE_MISS (P(SNOOP, NONE) \| P(SNOOP, MISS))
53		53
54	static const u64 pebs_data_source[] = {	54	static const u64 pebs_data_source[] = {
55	P(OP, LOAD) \| P(LVL, MISS) \| P(LVL, L3) \| P(SNOOP, NA),/* 0x00:ukn L3 */	55	P(OP, LOAD) \| P(LVL, MISS) \| P(LVL, L3) \| P(SNOOP, NA),/* 0x00:ukn L3 */
56	OP_LH \| P(LVL, L1) \| P(SNOOP, NONE), /* 0x01: L1 local */	56	OP_LH \| P(LVL, L1) \| P(SNOOP, NONE), /* 0x01: L1 local */
57	OP_LH \| P(LVL, LFB) \| P(SNOOP, NONE), /* 0x02: LFB hit */	57	OP_LH \| P(LVL, LFB) \| P(SNOOP, NONE), /* 0x02: LFB hit */
58	OP_LH \| P(LVL, L2) \| P(SNOOP, NONE), /* 0x03: L2 hit */	58	OP_LH \| P(LVL, L2) \| P(SNOOP, NONE), /* 0x03: L2 hit */
59	OP_LH \| P(LVL, L3) \| P(SNOOP, NONE), /* 0x04: L3 hit */	59	OP_LH \| P(LVL, L3) \| P(SNOOP, NONE), /* 0x04: L3 hit */
60	OP_LH \| P(LVL, L3) \| P(SNOOP, MISS), /* 0x05: L3 hit, snoop miss */	60	OP_LH \| P(LVL, L3) \| P(SNOOP, MISS), /* 0x05: L3 hit, snoop miss */
61	OP_LH \| P(LVL, L3) \| P(SNOOP, HIT), /* 0x06: L3 hit, snoop hit */	61	OP_LH \| P(LVL, L3) \| P(SNOOP, HIT), /* 0x06: L3 hit, snoop hit */
62	OP_LH \| P(LVL, L3) \| P(SNOOP, HITM), /* 0x07: L3 hit, snoop hitm */	62	OP_LH \| P(LVL, L3) \| P(SNOOP, HITM), /* 0x07: L3 hit, snoop hitm */
63	OP_LH \| P(LVL, REM_CCE1) \| P(SNOOP, HIT), /* 0x08: L3 miss snoop hit */	63	OP_LH \| P(LVL, REM_CCE1) \| P(SNOOP, HIT), /* 0x08: L3 miss snoop hit */
64	OP_LH \| P(LVL, REM_CCE1) \| P(SNOOP, HITM), /* 0x09: L3 miss snoop hitm*/	64	OP_LH \| P(LVL, REM_CCE1) \| P(SNOOP, HITM), /* 0x09: L3 miss snoop hitm*/
65	OP_LH \| P(LVL, LOC_RAM) \| P(SNOOP, HIT), /* 0x0a: L3 miss, shared */	65	OP_LH \| P(LVL, LOC_RAM) \| P(SNOOP, HIT), /* 0x0a: L3 miss, shared */
66	OP_LH \| P(LVL, REM_RAM1) \| P(SNOOP, HIT), /* 0x0b: L3 miss, shared */	66	OP_LH \| P(LVL, REM_RAM1) \| P(SNOOP, HIT), /* 0x0b: L3 miss, shared */
67	OP_LH \| P(LVL, LOC_RAM) \| SNOOP_NONE_MISS,/* 0x0c: L3 miss, excl */	67	OP_LH \| P(LVL, LOC_RAM) \| SNOOP_NONE_MISS,/* 0x0c: L3 miss, excl */
68	OP_LH \| P(LVL, REM_RAM1) \| SNOOP_NONE_MISS,/* 0x0d: L3 miss, excl */	68	OP_LH \| P(LVL, REM_RAM1) \| SNOOP_NONE_MISS,/* 0x0d: L3 miss, excl */
69	OP_LH \| P(LVL, IO) \| P(SNOOP, NONE), /* 0x0e: I/O */	69	OP_LH \| P(LVL, IO) \| P(SNOOP, NONE), /* 0x0e: I/O */
70	OP_LH \| P(LVL, UNC) \| P(SNOOP, NONE), /* 0x0f: uncached */	70	OP_LH \| P(LVL, UNC) \| P(SNOOP, NONE), /* 0x0f: uncached */
71	};	71	};
72		72
73	static u64 precise_store_data(u64 status)	73	static u64 precise_store_data(u64 status)
74	{	74	{
75	union intel_x86_pebs_dse dse;	75	union intel_x86_pebs_dse dse;
76	u64 val = P(OP, STORE) \| P(SNOOP, NA) \| P(LVL, L1) \| P(TLB, L2);	76	u64 val = P(OP, STORE) \| P(SNOOP, NA) \| P(LVL, L1) \| P(TLB, L2);
77		77
78	dse.val = status;	78	dse.val = status;
79		79
80	/*	80	/*
81	* bit 4: TLB access	81	* bit 4: TLB access
82	* 1 = stored missed 2nd level TLB	82	* 1 = stored missed 2nd level TLB
83	*	83	*
84	* so it either hit the walker or the OS	84	* so it either hit the walker or the OS
85	* otherwise hit 2nd level TLB	85	* otherwise hit 2nd level TLB
86	*/	86	*/
87	if (dse.st_stlb_miss)	87	if (dse.st_stlb_miss)
88	val \|= P(TLB, MISS);	88	val \|= P(TLB, MISS);
89	else	89	else
90	val \|= P(TLB, HIT);	90	val \|= P(TLB, HIT);
91		91
92	/*	92	/*
93	* bit 0: hit L1 data cache	93	* bit 0: hit L1 data cache
94	* if not set, then all we know is that	94	* if not set, then all we know is that
95	* it missed L1D	95	* it missed L1D
96	*/	96	*/
97	if (dse.st_l1d_hit)	97	if (dse.st_l1d_hit)
98	val \|= P(LVL, HIT);	98	val \|= P(LVL, HIT);
99	else	99	else
100	val \|= P(LVL, MISS);	100	val \|= P(LVL, MISS);
101		101
102	/*	102	/*
103	* bit 5: Locked prefix	103	* bit 5: Locked prefix
104	*/	104	*/
105	if (dse.st_locked)	105	if (dse.st_locked)
106	val \|= P(LOCK, LOCKED);	106	val \|= P(LOCK, LOCKED);
107		107
108	return val;	108	return val;
109	}	109	}
110		110
111	static u64 precise_datala_hsw(struct perf_event *event, u64 status)	111	static u64 precise_datala_hsw(struct perf_event *event, u64 status)
112	{	112	{
113	union perf_mem_data_src dse;	113	union perf_mem_data_src dse;
114		114
115	dse.val = PERF_MEM_NA;	115	dse.val = PERF_MEM_NA;
116		116
117	if (event->hw.flags & PERF_X86_EVENT_PEBS_ST_HSW)	117	if (event->hw.flags & PERF_X86_EVENT_PEBS_ST_HSW)
118	dse.mem_op = PERF_MEM_OP_STORE;	118	dse.mem_op = PERF_MEM_OP_STORE;
119	else if (event->hw.flags & PERF_X86_EVENT_PEBS_LD_HSW)	119	else if (event->hw.flags & PERF_X86_EVENT_PEBS_LD_HSW)
120	dse.mem_op = PERF_MEM_OP_LOAD;	120	dse.mem_op = PERF_MEM_OP_LOAD;
121		121
122	/*	122	/*
123	* L1 info only valid for following events:	123	* L1 info only valid for following events:
124	*	124	*
125	* MEM_UOPS_RETIRED.STLB_MISS_STORES	125	* MEM_UOPS_RETIRED.STLB_MISS_STORES
126	* MEM_UOPS_RETIRED.LOCK_STORES	126	* MEM_UOPS_RETIRED.LOCK_STORES
127	* MEM_UOPS_RETIRED.SPLIT_STORES	127	* MEM_UOPS_RETIRED.SPLIT_STORES
128	* MEM_UOPS_RETIRED.ALL_STORES	128	* MEM_UOPS_RETIRED.ALL_STORES
129	*/	129	*/
130	if (event->hw.flags & PERF_X86_EVENT_PEBS_ST_HSW) {	130	if (event->hw.flags & PERF_X86_EVENT_PEBS_ST_HSW) {
131	if (status & 1)	131	if (status & 1)
132	dse.mem_lvl = PERF_MEM_LVL_L1 \| PERF_MEM_LVL_HIT;	132	dse.mem_lvl = PERF_MEM_LVL_L1 \| PERF_MEM_LVL_HIT;
133	else	133	else
134	dse.mem_lvl = PERF_MEM_LVL_L1 \| PERF_MEM_LVL_MISS;	134	dse.mem_lvl = PERF_MEM_LVL_L1 \| PERF_MEM_LVL_MISS;
135	}	135	}
136	return dse.val;	136	return dse.val;
137	}	137	}
138		138
139	static u64 load_latency_data(u64 status)	139	static u64 load_latency_data(u64 status)
140	{	140	{
141	union intel_x86_pebs_dse dse;	141	union intel_x86_pebs_dse dse;
142	u64 val;	142	u64 val;
143	int model = boot_cpu_data.x86_model;	143	int model = boot_cpu_data.x86_model;
144	int fam = boot_cpu_data.x86;	144	int fam = boot_cpu_data.x86;
145		145
146	dse.val = status;	146	dse.val = status;
147		147
148	/*	148	/*
149	* use the mapping table for bit 0-3	149	* use the mapping table for bit 0-3
150	*/	150	*/
151	val = pebs_data_source[dse.ld_dse];	151	val = pebs_data_source[dse.ld_dse];
152		152
153	/*	153	/*
154	* Nehalem models do not support TLB, Lock infos	154	* Nehalem models do not support TLB, Lock infos
155	*/	155	*/
156	if (fam == 0x6 && (model == 26 \|\| model == 30	156	if (fam == 0x6 && (model == 26 \|\| model == 30
157	\|\| model == 31 \|\| model == 46)) {	157	\|\| model == 31 \|\| model == 46)) {
158	val \|= P(TLB, NA) \| P(LOCK, NA);	158	val \|= P(TLB, NA) \| P(LOCK, NA);
159	return val;	159	return val;
160	}	160	}
161	/*	161	/*
162	* bit 4: TLB access	162	* bit 4: TLB access
163	* 0 = did not miss 2nd level TLB	163	* 0 = did not miss 2nd level TLB
164	* 1 = missed 2nd level TLB	164	* 1 = missed 2nd level TLB
165	*/	165	*/
166	if (dse.ld_stlb_miss)	166	if (dse.ld_stlb_miss)
167	val \|= P(TLB, MISS) \| P(TLB, L2);	167	val \|= P(TLB, MISS) \| P(TLB, L2);
168	else	168	else
169	val \|= P(TLB, HIT) \| P(TLB, L1) \| P(TLB, L2);	169	val \|= P(TLB, HIT) \| P(TLB, L1) \| P(TLB, L2);
170		170
171	/*	171	/*
172	* bit 5: locked prefix	172	* bit 5: locked prefix
173	*/	173	*/
174	if (dse.ld_locked)	174	if (dse.ld_locked)
175	val \|= P(LOCK, LOCKED);	175	val \|= P(LOCK, LOCKED);
176		176
177	return val;	177	return val;
178	}	178	}
179		179
180	struct pebs_record_core {	180	struct pebs_record_core {
181	u64 flags, ip;	181	u64 flags, ip;
182	u64 ax, bx, cx, dx;	182	u64 ax, bx, cx, dx;
183	u64 si, di, bp, sp;	183	u64 si, di, bp, sp;
184	u64 r8, r9, r10, r11;	184	u64 r8, r9, r10, r11;
185	u64 r12, r13, r14, r15;	185	u64 r12, r13, r14, r15;
186	};	186	};
187		187
188	struct pebs_record_nhm {	188	struct pebs_record_nhm {
189	u64 flags, ip;	189	u64 flags, ip;
190	u64 ax, bx, cx, dx;	190	u64 ax, bx, cx, dx;
191	u64 si, di, bp, sp;	191	u64 si, di, bp, sp;
192	u64 r8, r9, r10, r11;	192	u64 r8, r9, r10, r11;
193	u64 r12, r13, r14, r15;	193	u64 r12, r13, r14, r15;
194	u64 status, dla, dse, lat;	194	u64 status, dla, dse, lat;
195	};	195	};
196		196
197	/*	197	/*
198	* Same as pebs_record_nhm, with two additional fields.	198	* Same as pebs_record_nhm, with two additional fields.
199	*/	199	*/
200	struct pebs_record_hsw {	200	struct pebs_record_hsw {
201	u64 flags, ip;	201	u64 flags, ip;
202	u64 ax, bx, cx, dx;	202	u64 ax, bx, cx, dx;
203	u64 si, di, bp, sp;	203	u64 si, di, bp, sp;
204	u64 r8, r9, r10, r11;	204	u64 r8, r9, r10, r11;
205	u64 r12, r13, r14, r15;	205	u64 r12, r13, r14, r15;
206	u64 status, dla, dse, lat;	206	u64 status, dla, dse, lat;
207	u64 real_ip, tsx_tuning;	207	u64 real_ip, tsx_tuning;
208	};	208	};
209		209
210	union hsw_tsx_tuning {	210	union hsw_tsx_tuning {
211	struct {	211	struct {
212	u32 cycles_last_block : 32,	212	u32 cycles_last_block : 32,
213	hle_abort : 1,	213	hle_abort : 1,
214	rtm_abort : 1,	214	rtm_abort : 1,
215	instruction_abort : 1,	215	instruction_abort : 1,
216	non_instruction_abort : 1,	216	non_instruction_abort : 1,
217	retry : 1,	217	retry : 1,
218	data_conflict : 1,	218	data_conflict : 1,
219	capacity_writes : 1,	219	capacity_writes : 1,
220	capacity_reads : 1;	220	capacity_reads : 1;
221	};	221	};
222	u64 value;	222	u64 value;
223	};	223	};
224		224
225	#define PEBS_HSW_TSX_FLAGS 0xff00000000ULL	225	#define PEBS_HSW_TSX_FLAGS 0xff00000000ULL
226		226
227	void init_debug_store_on_cpu(int cpu)	227	void init_debug_store_on_cpu(int cpu)
228	{	228	{
229	struct debug_store *ds = per_cpu(cpu_hw_events, cpu).ds;	229	struct debug_store *ds = per_cpu(cpu_hw_events, cpu).ds;
230		230
231	if (!ds)	231	if (!ds)
232	return;	232	return;
233		233
234	wrmsr_on_cpu(cpu, MSR_IA32_DS_AREA,	234	wrmsr_on_cpu(cpu, MSR_IA32_DS_AREA,
235	(u32)((u64)(unsigned long)ds),	235	(u32)((u64)(unsigned long)ds),
236	(u32)((u64)(unsigned long)ds >> 32));	236	(u32)((u64)(unsigned long)ds >> 32));
237	}	237	}
238		238
239	void fini_debug_store_on_cpu(int cpu)	239	void fini_debug_store_on_cpu(int cpu)
240	{	240	{
241	if (!per_cpu(cpu_hw_events, cpu).ds)	241	if (!per_cpu(cpu_hw_events, cpu).ds)
242	return;	242	return;
243		243
244	wrmsr_on_cpu(cpu, MSR_IA32_DS_AREA, 0, 0);	244	wrmsr_on_cpu(cpu, MSR_IA32_DS_AREA, 0, 0);
245	}	245	}
246		246
247	static DEFINE_PER_CPU(void *, insn_buffer);	247	static DEFINE_PER_CPU(void *, insn_buffer);
248		248
249	static int alloc_pebs_buffer(int cpu)	249	static int alloc_pebs_buffer(int cpu)
250	{	250	{
251	struct debug_store *ds = per_cpu(cpu_hw_events, cpu).ds;	251	struct debug_store *ds = per_cpu(cpu_hw_events, cpu).ds;
252	int node = cpu_to_node(cpu);	252	int node = cpu_to_node(cpu);
253	int max, thresh = 1; /* always use a single PEBS record */	253	int max, thresh = 1; /* always use a single PEBS record */
254	void buffer, ibuffer;	254	void buffer, ibuffer;
255		255
256	if (!x86_pmu.pebs)	256	if (!x86_pmu.pebs)
257	return 0;	257	return 0;
258		258
259	buffer = kzalloc_node(PEBS_BUFFER_SIZE, GFP_KERNEL, node);	259	buffer = kzalloc_node(PEBS_BUFFER_SIZE, GFP_KERNEL, node);
260	if (unlikely(!buffer))	260	if (unlikely(!buffer))
261	return -ENOMEM;	261	return -ENOMEM;
262		262
263	/*	263	/*
264	* HSW+ already provides us the eventing ip; no need to allocate this	264	* HSW+ already provides us the eventing ip; no need to allocate this
265	* buffer then.	265	* buffer then.
266	*/	266	*/
267	if (x86_pmu.intel_cap.pebs_format < 2) {	267	if (x86_pmu.intel_cap.pebs_format < 2) {
268	ibuffer = kzalloc_node(PEBS_FIXUP_SIZE, GFP_KERNEL, node);	268	ibuffer = kzalloc_node(PEBS_FIXUP_SIZE, GFP_KERNEL, node);
269	if (!ibuffer) {	269	if (!ibuffer) {
270	kfree(buffer);	270	kfree(buffer);
271	return -ENOMEM;	271	return -ENOMEM;
272	}	272	}
273	per_cpu(insn_buffer, cpu) = ibuffer;	273	per_cpu(insn_buffer, cpu) = ibuffer;
274	}	274	}
275		275
276	max = PEBS_BUFFER_SIZE / x86_pmu.pebs_record_size;	276	max = PEBS_BUFFER_SIZE / x86_pmu.pebs_record_size;
277		277
278	ds->pebs_buffer_base = (u64)(unsigned long)buffer;	278	ds->pebs_buffer_base = (u64)(unsigned long)buffer;
279	ds->pebs_index = ds->pebs_buffer_base;	279	ds->pebs_index = ds->pebs_buffer_base;
280	ds->pebs_absolute_maximum = ds->pebs_buffer_base +	280	ds->pebs_absolute_maximum = ds->pebs_buffer_base +
281	max * x86_pmu.pebs_record_size;	281	max * x86_pmu.pebs_record_size;
282		282
283	ds->pebs_interrupt_threshold = ds->pebs_buffer_base +	283	ds->pebs_interrupt_threshold = ds->pebs_buffer_base +
284	thresh * x86_pmu.pebs_record_size;	284	thresh * x86_pmu.pebs_record_size;
285		285
286	return 0;	286	return 0;
287	}	287	}
288		288
289	static void release_pebs_buffer(int cpu)	289	static void release_pebs_buffer(int cpu)
290	{	290	{
291	struct debug_store *ds = per_cpu(cpu_hw_events, cpu).ds;	291	struct debug_store *ds = per_cpu(cpu_hw_events, cpu).ds;
292		292
293	if (!ds \|\| !x86_pmu.pebs)	293	if (!ds \|\| !x86_pmu.pebs)
294	return;	294	return;
295		295
296	kfree(per_cpu(insn_buffer, cpu));	296	kfree(per_cpu(insn_buffer, cpu));
297	per_cpu(insn_buffer, cpu) = NULL;	297	per_cpu(insn_buffer, cpu) = NULL;
298		298
299	kfree((void *)(unsigned long)ds->pebs_buffer_base);	299	kfree((void *)(unsigned long)ds->pebs_buffer_base);
300	ds->pebs_buffer_base = 0;	300	ds->pebs_buffer_base = 0;
301	}	301	}
302		302
303	static int alloc_bts_buffer(int cpu)	303	static int alloc_bts_buffer(int cpu)
304	{	304	{
305	struct debug_store *ds = per_cpu(cpu_hw_events, cpu).ds;	305	struct debug_store *ds = per_cpu(cpu_hw_events, cpu).ds;
306	int node = cpu_to_node(cpu);	306	int node = cpu_to_node(cpu);
307	int max, thresh;	307	int max, thresh;
308	void *buffer;	308	void *buffer;
309		309
310	if (!x86_pmu.bts)	310	if (!x86_pmu.bts)
311	return 0;	311	return 0;
312		312
313	buffer = kzalloc_node(BTS_BUFFER_SIZE, GFP_KERNEL \| __GFP_NOWARN, node);	313	buffer = kzalloc_node(BTS_BUFFER_SIZE, GFP_KERNEL \| __GFP_NOWARN, node);
314	if (unlikely(!buffer)) {	314	if (unlikely(!buffer)) {
315	WARN_ONCE(1, "%s: BTS buffer allocation failure\n", __func__);	315	WARN_ONCE(1, "%s: BTS buffer allocation failure\n", __func__);
316	return -ENOMEM;	316	return -ENOMEM;
317	}	317	}
318		318
319	max = BTS_BUFFER_SIZE / BTS_RECORD_SIZE;	319	max = BTS_BUFFER_SIZE / BTS_RECORD_SIZE;
320	thresh = max / 16;	320	thresh = max / 16;
321		321
322	ds->bts_buffer_base = (u64)(unsigned long)buffer;	322	ds->bts_buffer_base = (u64)(unsigned long)buffer;
323	ds->bts_index = ds->bts_buffer_base;	323	ds->bts_index = ds->bts_buffer_base;
324	ds->bts_absolute_maximum = ds->bts_buffer_base +	324	ds->bts_absolute_maximum = ds->bts_buffer_base +
325	max * BTS_RECORD_SIZE;	325	max * BTS_RECORD_SIZE;
326	ds->bts_interrupt_threshold = ds->bts_absolute_maximum -	326	ds->bts_interrupt_threshold = ds->bts_absolute_maximum -
327	thresh * BTS_RECORD_SIZE;	327	thresh * BTS_RECORD_SIZE;
328		328
329	return 0;	329	return 0;
330	}	330	}
331		331
332	static void release_bts_buffer(int cpu)	332	static void release_bts_buffer(int cpu)
333	{	333	{
334	struct debug_store *ds = per_cpu(cpu_hw_events, cpu).ds;	334	struct debug_store *ds = per_cpu(cpu_hw_events, cpu).ds;
335		335
336	if (!ds \|\| !x86_pmu.bts)	336	if (!ds \|\| !x86_pmu.bts)
337	return;	337	return;
338		338
339	kfree((void *)(unsigned long)ds->bts_buffer_base);	339	kfree((void *)(unsigned long)ds->bts_buffer_base);
340	ds->bts_buffer_base = 0;	340	ds->bts_buffer_base = 0;
341	}	341	}
342		342
343	static int alloc_ds_buffer(int cpu)	343	static int alloc_ds_buffer(int cpu)
344	{	344	{
345	int node = cpu_to_node(cpu);	345	int node = cpu_to_node(cpu);
346	struct debug_store *ds;	346	struct debug_store *ds;
347		347
348	ds = kzalloc_node(sizeof(*ds), GFP_KERNEL, node);	348	ds = kzalloc_node(sizeof(*ds), GFP_KERNEL, node);
349	if (unlikely(!ds))	349	if (unlikely(!ds))
350	return -ENOMEM;	350	return -ENOMEM;
351		351
352	per_cpu(cpu_hw_events, cpu).ds = ds;	352	per_cpu(cpu_hw_events, cpu).ds = ds;
353		353
354	return 0;	354	return 0;
355	}	355	}
356		356
357	static void release_ds_buffer(int cpu)	357	static void release_ds_buffer(int cpu)
358	{	358	{
359	struct debug_store *ds = per_cpu(cpu_hw_events, cpu).ds;	359	struct debug_store *ds = per_cpu(cpu_hw_events, cpu).ds;
360		360
361	if (!ds)	361	if (!ds)
362	return;	362	return;
363		363
364	per_cpu(cpu_hw_events, cpu).ds = NULL;	364	per_cpu(cpu_hw_events, cpu).ds = NULL;
365	kfree(ds);	365	kfree(ds);
366	}	366	}
367		367
368	void release_ds_buffers(void)	368	void release_ds_buffers(void)
369	{	369	{
370	int cpu;	370	int cpu;
371		371
372	if (!x86_pmu.bts && !x86_pmu.pebs)	372	if (!x86_pmu.bts && !x86_pmu.pebs)
373	return;	373	return;
374		374
375	get_online_cpus();	375	get_online_cpus();
376	for_each_online_cpu(cpu)	376	for_each_online_cpu(cpu)
377	fini_debug_store_on_cpu(cpu);	377	fini_debug_store_on_cpu(cpu);
378		378
379	for_each_possible_cpu(cpu) {	379	for_each_possible_cpu(cpu) {
380	release_pebs_buffer(cpu);	380	release_pebs_buffer(cpu);
381	release_bts_buffer(cpu);	381	release_bts_buffer(cpu);
382	release_ds_buffer(cpu);	382	release_ds_buffer(cpu);
383	}	383	}
384	put_online_cpus();	384	put_online_cpus();
385	}	385	}
386		386
387	void reserve_ds_buffers(void)	387	void reserve_ds_buffers(void)
388	{	388	{
389	int bts_err = 0, pebs_err = 0;	389	int bts_err = 0, pebs_err = 0;
390	int cpu;	390	int cpu;
391		391
392	x86_pmu.bts_active = 0;	392	x86_pmu.bts_active = 0;
393	x86_pmu.pebs_active = 0;	393	x86_pmu.pebs_active = 0;
394		394
395	if (!x86_pmu.bts && !x86_pmu.pebs)	395	if (!x86_pmu.bts && !x86_pmu.pebs)
396	return;	396	return;
397		397
398	if (!x86_pmu.bts)	398	if (!x86_pmu.bts)
399	bts_err = 1;	399	bts_err = 1;
400		400
401	if (!x86_pmu.pebs)	401	if (!x86_pmu.pebs)
402	pebs_err = 1;	402	pebs_err = 1;
403		403
404	get_online_cpus();	404	get_online_cpus();
405		405
406	for_each_possible_cpu(cpu) {	406	for_each_possible_cpu(cpu) {
407	if (alloc_ds_buffer(cpu)) {	407	if (alloc_ds_buffer(cpu)) {
408	bts_err = 1;	408	bts_err = 1;
409	pebs_err = 1;	409	pebs_err = 1;
410	}	410	}
411		411
412	if (!bts_err && alloc_bts_buffer(cpu))	412	if (!bts_err && alloc_bts_buffer(cpu))
413	bts_err = 1;	413	bts_err = 1;
414		414
415	if (!pebs_err && alloc_pebs_buffer(cpu))	415	if (!pebs_err && alloc_pebs_buffer(cpu))
416	pebs_err = 1;	416	pebs_err = 1;
417		417
418	if (bts_err && pebs_err)	418	if (bts_err && pebs_err)
419	break;	419	break;
420	}	420	}
421		421
422	if (bts_err) {	422	if (bts_err) {
423	for_each_possible_cpu(cpu)	423	for_each_possible_cpu(cpu)
424	release_bts_buffer(cpu);	424	release_bts_buffer(cpu);
425	}	425	}
426		426
427	if (pebs_err) {	427	if (pebs_err) {
428	for_each_possible_cpu(cpu)	428	for_each_possible_cpu(cpu)
429	release_pebs_buffer(cpu);	429	release_pebs_buffer(cpu);
430	}	430	}
431		431
432	if (bts_err && pebs_err) {	432	if (bts_err && pebs_err) {
433	for_each_possible_cpu(cpu)	433	for_each_possible_cpu(cpu)
434	release_ds_buffer(cpu);	434	release_ds_buffer(cpu);
435	} else {	435	} else {
436	if (x86_pmu.bts && !bts_err)	436	if (x86_pmu.bts && !bts_err)
437	x86_pmu.bts_active = 1;	437	x86_pmu.bts_active = 1;
438		438
439	if (x86_pmu.pebs && !pebs_err)	439	if (x86_pmu.pebs && !pebs_err)
440	x86_pmu.pebs_active = 1;	440	x86_pmu.pebs_active = 1;
441		441
442	for_each_online_cpu(cpu)	442	for_each_online_cpu(cpu)
443	init_debug_store_on_cpu(cpu);	443	init_debug_store_on_cpu(cpu);
444	}	444	}
445		445
446	put_online_cpus();	446	put_online_cpus();
447	}	447	}
448		448
449	/*	449	/*
450	* BTS	450	* BTS
451	*/	451	*/
452		452
453	struct event_constraint bts_constraint =	453	struct event_constraint bts_constraint =
454	EVENT_CONSTRAINT(0, 1ULL << INTEL_PMC_IDX_FIXED_BTS, 0);	454	EVENT_CONSTRAINT(0, 1ULL << INTEL_PMC_IDX_FIXED_BTS, 0);
455		455
456	void intel_pmu_enable_bts(u64 config)	456	void intel_pmu_enable_bts(u64 config)
457	{	457	{
458	unsigned long debugctlmsr;	458	unsigned long debugctlmsr;
459		459
460	debugctlmsr = get_debugctlmsr();	460	debugctlmsr = get_debugctlmsr();
461		461
462	debugctlmsr \|= DEBUGCTLMSR_TR;	462	debugctlmsr \|= DEBUGCTLMSR_TR;
463	debugctlmsr \|= DEBUGCTLMSR_BTS;	463	debugctlmsr \|= DEBUGCTLMSR_BTS;
464	debugctlmsr \|= DEBUGCTLMSR_BTINT;	464	debugctlmsr \|= DEBUGCTLMSR_BTINT;
465		465
466	if (!(config & ARCH_PERFMON_EVENTSEL_OS))	466	if (!(config & ARCH_PERFMON_EVENTSEL_OS))
467	debugctlmsr \|= DEBUGCTLMSR_BTS_OFF_OS;	467	debugctlmsr \|= DEBUGCTLMSR_BTS_OFF_OS;
468		468
469	if (!(config & ARCH_PERFMON_EVENTSEL_USR))	469	if (!(config & ARCH_PERFMON_EVENTSEL_USR))
470	debugctlmsr \|= DEBUGCTLMSR_BTS_OFF_USR;	470	debugctlmsr \|= DEBUGCTLMSR_BTS_OFF_USR;
471		471
472	update_debugctlmsr(debugctlmsr);	472	update_debugctlmsr(debugctlmsr);
473	}	473	}
474		474
475	void intel_pmu_disable_bts(void)	475	void intel_pmu_disable_bts(void)
476	{	476	{
477	struct cpu_hw_events *cpuc = this_cpu_ptr(&cpu_hw_events);	477	struct cpu_hw_events *cpuc = this_cpu_ptr(&cpu_hw_events);
478	unsigned long debugctlmsr;	478	unsigned long debugctlmsr;
479		479
480	if (!cpuc->ds)	480	if (!cpuc->ds)
481	return;	481	return;
482		482
483	debugctlmsr = get_debugctlmsr();	483	debugctlmsr = get_debugctlmsr();
484		484
485	debugctlmsr &=	485	debugctlmsr &=
486	~(DEBUGCTLMSR_TR \| DEBUGCTLMSR_BTS \| DEBUGCTLMSR_BTINT \|	486	~(DEBUGCTLMSR_TR \| DEBUGCTLMSR_BTS \| DEBUGCTLMSR_BTINT \|
487	DEBUGCTLMSR_BTS_OFF_OS \| DEBUGCTLMSR_BTS_OFF_USR);	487	DEBUGCTLMSR_BTS_OFF_OS \| DEBUGCTLMSR_BTS_OFF_USR);
488		488
489	update_debugctlmsr(debugctlmsr);	489	update_debugctlmsr(debugctlmsr);
490	}	490	}
491		491
492	int intel_pmu_drain_bts_buffer(void)	492	int intel_pmu_drain_bts_buffer(void)
493	{	493	{
494	struct cpu_hw_events *cpuc = this_cpu_ptr(&cpu_hw_events);	494	struct cpu_hw_events *cpuc = this_cpu_ptr(&cpu_hw_events);
495	struct debug_store *ds = cpuc->ds;	495	struct debug_store *ds = cpuc->ds;
496	struct bts_record {	496	struct bts_record {
497	u64 from;	497	u64 from;
498	u64 to;	498	u64 to;
499	u64 flags;	499	u64 flags;
500	};	500	};
501	struct perf_event *event = cpuc->events[INTEL_PMC_IDX_FIXED_BTS];	501	struct perf_event *event = cpuc->events[INTEL_PMC_IDX_FIXED_BTS];
502	struct bts_record at, top;	502	struct bts_record at, top;
503	struct perf_output_handle handle;	503	struct perf_output_handle handle;
504	struct perf_event_header header;	504	struct perf_event_header header;
505	struct perf_sample_data data;	505	struct perf_sample_data data;
506	struct pt_regs regs;	506	struct pt_regs regs;
507		507
508	if (!event)	508	if (!event)
509	return 0;	509	return 0;
510		510
511	if (!x86_pmu.bts_active)	511	if (!x86_pmu.bts_active)
512	return 0;	512	return 0;
513		513
514	at = (struct bts_record *)(unsigned long)ds->bts_buffer_base;	514	at = (struct bts_record *)(unsigned long)ds->bts_buffer_base;
515	top = (struct bts_record *)(unsigned long)ds->bts_index;	515	top = (struct bts_record *)(unsigned long)ds->bts_index;
516		516
517	if (top <= at)	517	if (top <= at)
518	return 0;	518	return 0;
519		519
520	memset(&regs, 0, sizeof(regs));	520	memset(&regs, 0, sizeof(regs));
521		521
522	ds->bts_index = ds->bts_buffer_base;	522	ds->bts_index = ds->bts_buffer_base;
523		523
524	perf_sample_data_init(&data, 0, event->hw.last_period);	524	perf_sample_data_init(&data, 0, event->hw.last_period);
525		525
526	/*	526	/*
527	* Prepare a generic sample, i.e. fill in the invariant fields.	527	* Prepare a generic sample, i.e. fill in the invariant fields.
528	* We will overwrite the from and to address before we output	528	* We will overwrite the from and to address before we output
529	* the sample.	529	* the sample.
530	*/	530	*/
531	perf_prepare_sample(&header, &data, event, &regs);	531	perf_prepare_sample(&header, &data, event, &regs);
532		532
533	if (perf_output_begin(&handle, event, header.size * (top - at)))	533	if (perf_output_begin(&handle, event, header.size * (top - at)))
534	return 1;	534	return 1;
535		535
536	for (; at < top; at++) {	536	for (; at < top; at++) {
537	data.ip = at->from;	537	data.ip = at->from;
538	data.addr = at->to;	538	data.addr = at->to;
539		539
540	perf_output_sample(&handle, &header, &data, event);	540	perf_output_sample(&handle, &header, &data, event);
541	}	541	}
542		542
543	perf_output_end(&handle);	543	perf_output_end(&handle);
544		544
545	/* There's new data available. */	545	/* There's new data available. */
546	event->hw.interrupts++;	546	event->hw.interrupts++;
547	event->pending_kill = POLL_IN;	547	event->pending_kill = POLL_IN;
548	return 1;	548	return 1;
549	}	549	}
550		550
551	/*	551	/*
552	* PEBS	552	* PEBS
553	*/	553	*/
554	struct event_constraint intel_core2_pebs_event_constraints[] = {	554	struct event_constraint intel_core2_pebs_event_constraints[] = {
555	INTEL_FLAGS_UEVENT_CONSTRAINT(0x00c0, 0x1), /* INST_RETIRED.ANY */	555	INTEL_FLAGS_UEVENT_CONSTRAINT(0x00c0, 0x1), /* INST_RETIRED.ANY */
556	INTEL_FLAGS_UEVENT_CONSTRAINT(0xfec1, 0x1), /* X87_OPS_RETIRED.ANY */	556	INTEL_FLAGS_UEVENT_CONSTRAINT(0xfec1, 0x1), /* X87_OPS_RETIRED.ANY */
557	INTEL_FLAGS_UEVENT_CONSTRAINT(0x00c5, 0x1), /* BR_INST_RETIRED.MISPRED */	557	INTEL_FLAGS_UEVENT_CONSTRAINT(0x00c5, 0x1), /* BR_INST_RETIRED.MISPRED */
558	INTEL_FLAGS_UEVENT_CONSTRAINT(0x1fc7, 0x1), /* SIMD_INST_RETURED.ANY */	558	INTEL_FLAGS_UEVENT_CONSTRAINT(0x1fc7, 0x1), /* SIMD_INST_RETURED.ANY */
559	INTEL_FLAGS_EVENT_CONSTRAINT(0xcb, 0x1), /* MEM_LOAD_RETIRED.* */	559	INTEL_FLAGS_EVENT_CONSTRAINT(0xcb, 0x1), /* MEM_LOAD_RETIRED.* */
560	EVENT_CONSTRAINT_END	560	EVENT_CONSTRAINT_END
561	};	561	};
562		562
563	struct event_constraint intel_atom_pebs_event_constraints[] = {	563	struct event_constraint intel_atom_pebs_event_constraints[] = {
564	INTEL_FLAGS_UEVENT_CONSTRAINT(0x00c0, 0x1), /* INST_RETIRED.ANY */	564	INTEL_FLAGS_UEVENT_CONSTRAINT(0x00c0, 0x1), /* INST_RETIRED.ANY */
565	INTEL_FLAGS_UEVENT_CONSTRAINT(0x00c5, 0x1), /* MISPREDICTED_BRANCH_RETIRED */	565	INTEL_FLAGS_UEVENT_CONSTRAINT(0x00c5, 0x1), /* MISPREDICTED_BRANCH_RETIRED */
566	INTEL_FLAGS_EVENT_CONSTRAINT(0xcb, 0x1), /* MEM_LOAD_RETIRED.* */	566	INTEL_FLAGS_EVENT_CONSTRAINT(0xcb, 0x1), /* MEM_LOAD_RETIRED.* */
567	EVENT_CONSTRAINT_END	567	EVENT_CONSTRAINT_END
568	};	568	};
569		569
570	struct event_constraint intel_slm_pebs_event_constraints[] = {	570	struct event_constraint intel_slm_pebs_event_constraints[] = {
571	/* UOPS_RETIRED.ALL, inv=1, cmask=16 (cycles:p). */	571	/* INST_RETIRED.ANY_P, inv=1, cmask=16 (cycles:p). */
572	INTEL_FLAGS_EVENT_CONSTRAINT(0x108001c2, 0xf),	572	INTEL_FLAGS_EVENT_CONSTRAINT(0x108000c0, 0x1),
573	/* Allow all events as PEBS with no flags */	573	/* Allow all events as PEBS with no flags */
574	INTEL_ALL_EVENT_CONSTRAINT(0, 0x1),	574	INTEL_ALL_EVENT_CONSTRAINT(0, 0x1),
575	EVENT_CONSTRAINT_END	575	EVENT_CONSTRAINT_END
576	};	576	};
577		577
578	struct event_constraint intel_nehalem_pebs_event_constraints[] = {	578	struct event_constraint intel_nehalem_pebs_event_constraints[] = {
579	INTEL_PLD_CONSTRAINT(0x100b, 0xf), /* MEM_INST_RETIRED.* */	579	INTEL_PLD_CONSTRAINT(0x100b, 0xf), /* MEM_INST_RETIRED.* */
580	INTEL_FLAGS_EVENT_CONSTRAINT(0x0f, 0xf), /* MEM_UNCORE_RETIRED.* */	580	INTEL_FLAGS_EVENT_CONSTRAINT(0x0f, 0xf), /* MEM_UNCORE_RETIRED.* */
581	INTEL_FLAGS_UEVENT_CONSTRAINT(0x010c, 0xf), /* MEM_STORE_RETIRED.DTLB_MISS */	581	INTEL_FLAGS_UEVENT_CONSTRAINT(0x010c, 0xf), /* MEM_STORE_RETIRED.DTLB_MISS */
582	INTEL_FLAGS_EVENT_CONSTRAINT(0xc0, 0xf), /* INST_RETIRED.ANY */	582	INTEL_FLAGS_EVENT_CONSTRAINT(0xc0, 0xf), /* INST_RETIRED.ANY */
583	INTEL_EVENT_CONSTRAINT(0xc2, 0xf), /* UOPS_RETIRED.* */	583	INTEL_EVENT_CONSTRAINT(0xc2, 0xf), /* UOPS_RETIRED.* */
584	INTEL_FLAGS_EVENT_CONSTRAINT(0xc4, 0xf), /* BR_INST_RETIRED.* */	584	INTEL_FLAGS_EVENT_CONSTRAINT(0xc4, 0xf), /* BR_INST_RETIRED.* */
585	INTEL_FLAGS_UEVENT_CONSTRAINT(0x02c5, 0xf), /* BR_MISP_RETIRED.NEAR_CALL */	585	INTEL_FLAGS_UEVENT_CONSTRAINT(0x02c5, 0xf), /* BR_MISP_RETIRED.NEAR_CALL */
586	INTEL_FLAGS_EVENT_CONSTRAINT(0xc7, 0xf), /* SSEX_UOPS_RETIRED.* */	586	INTEL_FLAGS_EVENT_CONSTRAINT(0xc7, 0xf), /* SSEX_UOPS_RETIRED.* */
587	INTEL_FLAGS_UEVENT_CONSTRAINT(0x20c8, 0xf), /* ITLB_MISS_RETIRED */	587	INTEL_FLAGS_UEVENT_CONSTRAINT(0x20c8, 0xf), /* ITLB_MISS_RETIRED */
588	INTEL_FLAGS_EVENT_CONSTRAINT(0xcb, 0xf), /* MEM_LOAD_RETIRED.* */	588	INTEL_FLAGS_EVENT_CONSTRAINT(0xcb, 0xf), /* MEM_LOAD_RETIRED.* */
589	INTEL_FLAGS_EVENT_CONSTRAINT(0xf7, 0xf), /* FP_ASSIST.* */	589	INTEL_FLAGS_EVENT_CONSTRAINT(0xf7, 0xf), /* FP_ASSIST.* */
590	EVENT_CONSTRAINT_END	590	EVENT_CONSTRAINT_END
591	};	591	};
592		592
593	struct event_constraint intel_westmere_pebs_event_constraints[] = {	593	struct event_constraint intel_westmere_pebs_event_constraints[] = {
594	INTEL_PLD_CONSTRAINT(0x100b, 0xf), /* MEM_INST_RETIRED.* */	594	INTEL_PLD_CONSTRAINT(0x100b, 0xf), /* MEM_INST_RETIRED.* */
595	INTEL_FLAGS_EVENT_CONSTRAINT(0x0f, 0xf), /* MEM_UNCORE_RETIRED.* */	595	INTEL_FLAGS_EVENT_CONSTRAINT(0x0f, 0xf), /* MEM_UNCORE_RETIRED.* */
596	INTEL_FLAGS_UEVENT_CONSTRAINT(0x010c, 0xf), /* MEM_STORE_RETIRED.DTLB_MISS */	596	INTEL_FLAGS_UEVENT_CONSTRAINT(0x010c, 0xf), /* MEM_STORE_RETIRED.DTLB_MISS */
597	INTEL_FLAGS_EVENT_CONSTRAINT(0xc0, 0xf), /* INSTR_RETIRED.* */	597	INTEL_FLAGS_EVENT_CONSTRAINT(0xc0, 0xf), /* INSTR_RETIRED.* */
598	INTEL_EVENT_CONSTRAINT(0xc2, 0xf), /* UOPS_RETIRED.* */	598	INTEL_EVENT_CONSTRAINT(0xc2, 0xf), /* UOPS_RETIRED.* */
599	INTEL_FLAGS_EVENT_CONSTRAINT(0xc4, 0xf), /* BR_INST_RETIRED.* */	599	INTEL_FLAGS_EVENT_CONSTRAINT(0xc4, 0xf), /* BR_INST_RETIRED.* */
600	INTEL_FLAGS_EVENT_CONSTRAINT(0xc5, 0xf), /* BR_MISP_RETIRED.* */	600	INTEL_FLAGS_EVENT_CONSTRAINT(0xc5, 0xf), /* BR_MISP_RETIRED.* */
601	INTEL_FLAGS_EVENT_CONSTRAINT(0xc7, 0xf), /* SSEX_UOPS_RETIRED.* */	601	INTEL_FLAGS_EVENT_CONSTRAINT(0xc7, 0xf), /* SSEX_UOPS_RETIRED.* */
602	INTEL_FLAGS_UEVENT_CONSTRAINT(0x20c8, 0xf), /* ITLB_MISS_RETIRED */	602	INTEL_FLAGS_UEVENT_CONSTRAINT(0x20c8, 0xf), /* ITLB_MISS_RETIRED */
603	INTEL_FLAGS_EVENT_CONSTRAINT(0xcb, 0xf), /* MEM_LOAD_RETIRED.* */	603	INTEL_FLAGS_EVENT_CONSTRAINT(0xcb, 0xf), /* MEM_LOAD_RETIRED.* */
604	INTEL_FLAGS_EVENT_CONSTRAINT(0xf7, 0xf), /* FP_ASSIST.* */	604	INTEL_FLAGS_EVENT_CONSTRAINT(0xf7, 0xf), /* FP_ASSIST.* */
605	EVENT_CONSTRAINT_END	605	EVENT_CONSTRAINT_END
606	};	606	};
607		607
608	struct event_constraint intel_snb_pebs_event_constraints[] = {	608	struct event_constraint intel_snb_pebs_event_constraints[] = {
609	INTEL_FLAGS_UEVENT_CONSTRAINT(0x01c0, 0x2), /* INST_RETIRED.PRECDIST */	609	INTEL_FLAGS_UEVENT_CONSTRAINT(0x01c0, 0x2), /* INST_RETIRED.PRECDIST */
610	INTEL_PLD_CONSTRAINT(0x01cd, 0x8), /* MEM_TRANS_RETIRED.LAT_ABOVE_THR */	610	INTEL_PLD_CONSTRAINT(0x01cd, 0x8), /* MEM_TRANS_RETIRED.LAT_ABOVE_THR */
611	INTEL_PST_CONSTRAINT(0x02cd, 0x8), /* MEM_TRANS_RETIRED.PRECISE_STORES */	611	INTEL_PST_CONSTRAINT(0x02cd, 0x8), /* MEM_TRANS_RETIRED.PRECISE_STORES */
612	/* UOPS_RETIRED.ALL, inv=1, cmask=16 (cycles:p). */	612	/* UOPS_RETIRED.ALL, inv=1, cmask=16 (cycles:p). */
613	INTEL_FLAGS_EVENT_CONSTRAINT(0x108001c2, 0xf),	613	INTEL_FLAGS_EVENT_CONSTRAINT(0x108001c2, 0xf),
614	/* Allow all events as PEBS with no flags */	614	/* Allow all events as PEBS with no flags */
615	INTEL_ALL_EVENT_CONSTRAINT(0, 0xf),	615	INTEL_ALL_EVENT_CONSTRAINT(0, 0xf),
616	EVENT_CONSTRAINT_END	616	EVENT_CONSTRAINT_END
617	};	617	};
618		618
619	struct event_constraint intel_ivb_pebs_event_constraints[] = {	619	struct event_constraint intel_ivb_pebs_event_constraints[] = {
620	INTEL_FLAGS_UEVENT_CONSTRAINT(0x01c0, 0x2), /* INST_RETIRED.PRECDIST */	620	INTEL_FLAGS_UEVENT_CONSTRAINT(0x01c0, 0x2), /* INST_RETIRED.PRECDIST */
621	INTEL_PLD_CONSTRAINT(0x01cd, 0x8), /* MEM_TRANS_RETIRED.LAT_ABOVE_THR */	621	INTEL_PLD_CONSTRAINT(0x01cd, 0x8), /* MEM_TRANS_RETIRED.LAT_ABOVE_THR */
622	INTEL_PST_CONSTRAINT(0x02cd, 0x8), /* MEM_TRANS_RETIRED.PRECISE_STORES */	622	INTEL_PST_CONSTRAINT(0x02cd, 0x8), /* MEM_TRANS_RETIRED.PRECISE_STORES */
623	/* UOPS_RETIRED.ALL, inv=1, cmask=16 (cycles:p). */	623	/* UOPS_RETIRED.ALL, inv=1, cmask=16 (cycles:p). */
624	INTEL_FLAGS_EVENT_CONSTRAINT(0x108001c2, 0xf),	624	INTEL_FLAGS_EVENT_CONSTRAINT(0x108001c2, 0xf),
625	/* Allow all events as PEBS with no flags */	625	/* Allow all events as PEBS with no flags */
626	INTEL_ALL_EVENT_CONSTRAINT(0, 0xf),	626	INTEL_ALL_EVENT_CONSTRAINT(0, 0xf),
627	EVENT_CONSTRAINT_END	627	EVENT_CONSTRAINT_END
628	};	628	};
629		629
630	struct event_constraint intel_hsw_pebs_event_constraints[] = {	630	struct event_constraint intel_hsw_pebs_event_constraints[] = {
631	INTEL_FLAGS_UEVENT_CONSTRAINT(0x01c0, 0x2), /* INST_RETIRED.PRECDIST */	631	INTEL_FLAGS_UEVENT_CONSTRAINT(0x01c0, 0x2), /* INST_RETIRED.PRECDIST */
632	INTEL_PLD_CONSTRAINT(0x01cd, 0xf), /* MEM_TRANS_RETIRED.* */	632	INTEL_PLD_CONSTRAINT(0x01cd, 0xf), /* MEM_TRANS_RETIRED.* */
633	/* UOPS_RETIRED.ALL, inv=1, cmask=16 (cycles:p). */	633	/* UOPS_RETIRED.ALL, inv=1, cmask=16 (cycles:p). */
634	INTEL_FLAGS_EVENT_CONSTRAINT(0x108001c2, 0xf),	634	INTEL_FLAGS_EVENT_CONSTRAINT(0x108001c2, 0xf),
635	INTEL_FLAGS_UEVENT_CONSTRAINT_DATALA_NA(0x01c2, 0xf), /* UOPS_RETIRED.ALL */	635	INTEL_FLAGS_UEVENT_CONSTRAINT_DATALA_NA(0x01c2, 0xf), /* UOPS_RETIRED.ALL */
636	INTEL_FLAGS_UEVENT_CONSTRAINT_DATALA_LD(0x11d0, 0xf), /* MEM_UOPS_RETIRED.STLB_MISS_LOADS */	636	INTEL_FLAGS_UEVENT_CONSTRAINT_DATALA_LD(0x11d0, 0xf), /* MEM_UOPS_RETIRED.STLB_MISS_LOADS */
637	INTEL_FLAGS_UEVENT_CONSTRAINT_DATALA_LD(0x21d0, 0xf), /* MEM_UOPS_RETIRED.LOCK_LOADS */	637	INTEL_FLAGS_UEVENT_CONSTRAINT_DATALA_LD(0x21d0, 0xf), /* MEM_UOPS_RETIRED.LOCK_LOADS */
638	INTEL_FLAGS_UEVENT_CONSTRAINT_DATALA_LD(0x41d0, 0xf), /* MEM_UOPS_RETIRED.SPLIT_LOADS */	638	INTEL_FLAGS_UEVENT_CONSTRAINT_DATALA_LD(0x41d0, 0xf), /* MEM_UOPS_RETIRED.SPLIT_LOADS */
639	INTEL_FLAGS_UEVENT_CONSTRAINT_DATALA_LD(0x81d0, 0xf), /* MEM_UOPS_RETIRED.ALL_LOADS */	639	INTEL_FLAGS_UEVENT_CONSTRAINT_DATALA_LD(0x81d0, 0xf), /* MEM_UOPS_RETIRED.ALL_LOADS */
640	INTEL_FLAGS_UEVENT_CONSTRAINT_DATALA_ST(0x12d0, 0xf), /* MEM_UOPS_RETIRED.STLB_MISS_STORES */	640	INTEL_FLAGS_UEVENT_CONSTRAINT_DATALA_ST(0x12d0, 0xf), /* MEM_UOPS_RETIRED.STLB_MISS_STORES */
641	INTEL_FLAGS_UEVENT_CONSTRAINT_DATALA_ST(0x42d0, 0xf), /* MEM_UOPS_RETIRED.SPLIT_STORES */	641	INTEL_FLAGS_UEVENT_CONSTRAINT_DATALA_ST(0x42d0, 0xf), /* MEM_UOPS_RETIRED.SPLIT_STORES */
642	INTEL_FLAGS_UEVENT_CONSTRAINT_DATALA_ST(0x82d0, 0xf), /* MEM_UOPS_RETIRED.ALL_STORES */	642	INTEL_FLAGS_UEVENT_CONSTRAINT_DATALA_ST(0x82d0, 0xf), /* MEM_UOPS_RETIRED.ALL_STORES */
643	INTEL_FLAGS_EVENT_CONSTRAINT_DATALA_LD(0xd1, 0xf), /* MEM_LOAD_UOPS_RETIRED.* */	643	INTEL_FLAGS_EVENT_CONSTRAINT_DATALA_LD(0xd1, 0xf), /* MEM_LOAD_UOPS_RETIRED.* */
644	INTEL_FLAGS_EVENT_CONSTRAINT_DATALA_LD(0xd2, 0xf), /* MEM_LOAD_UOPS_L3_HIT_RETIRED.* */	644	INTEL_FLAGS_EVENT_CONSTRAINT_DATALA_LD(0xd2, 0xf), /* MEM_LOAD_UOPS_L3_HIT_RETIRED.* */
645	INTEL_FLAGS_EVENT_CONSTRAINT_DATALA_LD(0xd3, 0xf), /* MEM_LOAD_UOPS_L3_MISS_RETIRED.* */	645	INTEL_FLAGS_EVENT_CONSTRAINT_DATALA_LD(0xd3, 0xf), /* MEM_LOAD_UOPS_L3_MISS_RETIRED.* */
646	/* Allow all events as PEBS with no flags */	646	/* Allow all events as PEBS with no flags */
647	INTEL_ALL_EVENT_CONSTRAINT(0, 0xf),	647	INTEL_ALL_EVENT_CONSTRAINT(0, 0xf),
648	EVENT_CONSTRAINT_END	648	EVENT_CONSTRAINT_END
649	};	649	};
650		650
651	struct event_constraint intel_pebs_constraints(struct perf_event event)	651	struct event_constraint intel_pebs_constraints(struct perf_event event)
652	{	652	{
653	struct event_constraint *c;	653	struct event_constraint *c;
654		654
655	if (!event->attr.precise_ip)	655	if (!event->attr.precise_ip)
656	return NULL;	656	return NULL;
657		657
658	if (x86_pmu.pebs_constraints) {	658	if (x86_pmu.pebs_constraints) {
659	for_each_event_constraint(c, x86_pmu.pebs_constraints) {	659	for_each_event_constraint(c, x86_pmu.pebs_constraints) {
660	if ((event->hw.config & c->cmask) == c->code) {	660	if ((event->hw.config & c->cmask) == c->code) {
661	event->hw.flags \|= c->flags;	661	event->hw.flags \|= c->flags;
662	return c;	662	return c;
663	}	663	}
664	}	664	}
665	}	665	}
666		666
667	return &emptyconstraint;	667	return &emptyconstraint;
668	}	668	}
669		669
670	void intel_pmu_pebs_enable(struct perf_event *event)	670	void intel_pmu_pebs_enable(struct perf_event *event)
671	{	671	{
672	struct cpu_hw_events *cpuc = this_cpu_ptr(&cpu_hw_events);	672	struct cpu_hw_events *cpuc = this_cpu_ptr(&cpu_hw_events);
673	struct hw_perf_event *hwc = &event->hw;	673	struct hw_perf_event *hwc = &event->hw;
674		674
675	hwc->config &= ~ARCH_PERFMON_EVENTSEL_INT;	675	hwc->config &= ~ARCH_PERFMON_EVENTSEL_INT;
676		676
677	cpuc->pebs_enabled \|= 1ULL << hwc->idx;	677	cpuc->pebs_enabled \|= 1ULL << hwc->idx;
678		678
679	if (event->hw.flags & PERF_X86_EVENT_PEBS_LDLAT)	679	if (event->hw.flags & PERF_X86_EVENT_PEBS_LDLAT)
680	cpuc->pebs_enabled \|= 1ULL << (hwc->idx + 32);	680	cpuc->pebs_enabled \|= 1ULL << (hwc->idx + 32);
681	else if (event->hw.flags & PERF_X86_EVENT_PEBS_ST)	681	else if (event->hw.flags & PERF_X86_EVENT_PEBS_ST)
682	cpuc->pebs_enabled \|= 1ULL << 63;	682	cpuc->pebs_enabled \|= 1ULL << 63;
683	}	683	}
684		684
685	void intel_pmu_pebs_disable(struct perf_event *event)	685	void intel_pmu_pebs_disable(struct perf_event *event)
686	{	686	{
687	struct cpu_hw_events *cpuc = this_cpu_ptr(&cpu_hw_events);	687	struct cpu_hw_events *cpuc = this_cpu_ptr(&cpu_hw_events);
688	struct hw_perf_event *hwc = &event->hw;	688	struct hw_perf_event *hwc = &event->hw;
689		689
690	cpuc->pebs_enabled &= ~(1ULL << hwc->idx);	690	cpuc->pebs_enabled &= ~(1ULL << hwc->idx);
691		691
692	if (event->hw.constraint->flags & PERF_X86_EVENT_PEBS_LDLAT)	692	if (event->hw.constraint->flags & PERF_X86_EVENT_PEBS_LDLAT)
693	cpuc->pebs_enabled &= ~(1ULL << (hwc->idx + 32));	693	cpuc->pebs_enabled &= ~(1ULL << (hwc->idx + 32));
694	else if (event->hw.constraint->flags & PERF_X86_EVENT_PEBS_ST)	694	else if (event->hw.constraint->flags & PERF_X86_EVENT_PEBS_ST)
695	cpuc->pebs_enabled &= ~(1ULL << 63);	695	cpuc->pebs_enabled &= ~(1ULL << 63);
696		696
697	if (cpuc->enabled)	697	if (cpuc->enabled)
698	wrmsrl(MSR_IA32_PEBS_ENABLE, cpuc->pebs_enabled);	698	wrmsrl(MSR_IA32_PEBS_ENABLE, cpuc->pebs_enabled);
699		699
700	hwc->config \|= ARCH_PERFMON_EVENTSEL_INT;	700	hwc->config \|= ARCH_PERFMON_EVENTSEL_INT;
701	}	701	}
702		702
703	void intel_pmu_pebs_enable_all(void)	703	void intel_pmu_pebs_enable_all(void)
704	{	704	{
705	struct cpu_hw_events *cpuc = this_cpu_ptr(&cpu_hw_events);	705	struct cpu_hw_events *cpuc = this_cpu_ptr(&cpu_hw_events);
706		706
707	if (cpuc->pebs_enabled)	707	if (cpuc->pebs_enabled)
708	wrmsrl(MSR_IA32_PEBS_ENABLE, cpuc->pebs_enabled);	708	wrmsrl(MSR_IA32_PEBS_ENABLE, cpuc->pebs_enabled);
709	}	709	}
710		710
711	void intel_pmu_pebs_disable_all(void)	711	void intel_pmu_pebs_disable_all(void)
712	{	712	{
713	struct cpu_hw_events *cpuc = this_cpu_ptr(&cpu_hw_events);	713	struct cpu_hw_events *cpuc = this_cpu_ptr(&cpu_hw_events);
714		714
715	if (cpuc->pebs_enabled)	715	if (cpuc->pebs_enabled)
716	wrmsrl(MSR_IA32_PEBS_ENABLE, 0);	716	wrmsrl(MSR_IA32_PEBS_ENABLE, 0);
717	}	717	}
718		718
719	static int intel_pmu_pebs_fixup_ip(struct pt_regs *regs)	719	static int intel_pmu_pebs_fixup_ip(struct pt_regs *regs)
720	{	720	{
721	struct cpu_hw_events *cpuc = this_cpu_ptr(&cpu_hw_events);	721	struct cpu_hw_events *cpuc = this_cpu_ptr(&cpu_hw_events);
722	unsigned long from = cpuc->lbr_entries[0].from;	722	unsigned long from = cpuc->lbr_entries[0].from;
723	unsigned long old_to, to = cpuc->lbr_entries[0].to;	723	unsigned long old_to, to = cpuc->lbr_entries[0].to;
724	unsigned long ip = regs->ip;	724	unsigned long ip = regs->ip;
725	int is_64bit = 0;	725	int is_64bit = 0;
726	void *kaddr;	726	void *kaddr;
727	int size;	727	int size;
728		728
729	/*	729	/*
730	* We don't need to fixup if the PEBS assist is fault like	730	* We don't need to fixup if the PEBS assist is fault like
731	*/	731	*/
732	if (!x86_pmu.intel_cap.pebs_trap)	732	if (!x86_pmu.intel_cap.pebs_trap)
733	return 1;	733	return 1;
734		734
735	/*	735	/*
736	* No LBR entry, no basic block, no rewinding	736	* No LBR entry, no basic block, no rewinding
737	*/	737	*/
738	if (!cpuc->lbr_stack.nr \|\| !from \|\| !to)	738	if (!cpuc->lbr_stack.nr \|\| !from \|\| !to)
739	return 0;	739	return 0;
740		740
741	/*	741	/*
742	* Basic blocks should never cross user/kernel boundaries	742	* Basic blocks should never cross user/kernel boundaries
743	*/	743	*/
744	if (kernel_ip(ip) != kernel_ip(to))	744	if (kernel_ip(ip) != kernel_ip(to))
745	return 0;	745	return 0;
746		746
747	/*	747	/*
748	* unsigned math, either ip is before the start (impossible) or	748	* unsigned math, either ip is before the start (impossible) or
749	* the basic block is larger than 1 page (sanity)	749	* the basic block is larger than 1 page (sanity)
750	*/	750	*/
751	if ((ip - to) > PEBS_FIXUP_SIZE)	751	if ((ip - to) > PEBS_FIXUP_SIZE)
752	return 0;	752	return 0;
753		753
754	/*	754	/*
755	* We sampled a branch insn, rewind using the LBR stack	755	* We sampled a branch insn, rewind using the LBR stack
756	*/	756	*/
757	if (ip == to) {	757	if (ip == to) {
758	set_linear_ip(regs, from);	758	set_linear_ip(regs, from);
759	return 1;	759	return 1;
760	}	760	}
761		761
762	size = ip - to;	762	size = ip - to;
763	if (!kernel_ip(ip)) {	763	if (!kernel_ip(ip)) {
764	int bytes;	764	int bytes;
765	u8 *buf = this_cpu_read(insn_buffer);	765	u8 *buf = this_cpu_read(insn_buffer);
766		766
767	/* 'size' must fit our buffer, see above */	767	/* 'size' must fit our buffer, see above */
768	bytes = copy_from_user_nmi(buf, (void __user *)to, size);	768	bytes = copy_from_user_nmi(buf, (void __user *)to, size);
769	if (bytes != 0)	769	if (bytes != 0)
770	return 0;	770	return 0;
771		771
772	kaddr = buf;	772	kaddr = buf;
773	} else {	773	} else {
774	kaddr = (void *)to;	774	kaddr = (void *)to;
775	}	775	}
776		776
777	do {	777	do {
778	struct insn insn;	778	struct insn insn;
779		779
780	old_to = to;	780	old_to = to;
781		781
782	#ifdef CONFIG_X86_64	782	#ifdef CONFIG_X86_64
783	is_64bit = kernel_ip(to) \|\| !test_thread_flag(TIF_IA32);	783	is_64bit = kernel_ip(to) \|\| !test_thread_flag(TIF_IA32);
784	#endif	784	#endif
785	insn_init(&insn, kaddr, size, is_64bit);	785	insn_init(&insn, kaddr, size, is_64bit);
786	insn_get_length(&insn);	786	insn_get_length(&insn);
787	/*	787	/*
788	* Make sure there was not a problem decoding the	788	* Make sure there was not a problem decoding the
789	* instruction and getting the length. This is	789	* instruction and getting the length. This is
790	* doubly important because we have an infinite	790	* doubly important because we have an infinite
791	* loop if insn.length=0.	791	* loop if insn.length=0.
792	*/	792	*/
793	if (!insn.length)	793	if (!insn.length)
794	break;	794	break;
795		795
796	to += insn.length;	796	to += insn.length;
797	kaddr += insn.length;	797	kaddr += insn.length;
798	size -= insn.length;	798	size -= insn.length;
799	} while (to < ip);	799	} while (to < ip);
800		800
801	if (to == ip) {	801	if (to == ip) {
802	set_linear_ip(regs, old_to);	802	set_linear_ip(regs, old_to);
803	return 1;	803	return 1;
804	}	804	}
805		805
806	/*	806	/*
807	* Even though we decoded the basic block, the instruction stream	807	* Even though we decoded the basic block, the instruction stream
808	* never matched the given IP, either the TO or the IP got corrupted.	808	* never matched the given IP, either the TO or the IP got corrupted.
809	*/	809	*/
810	return 0;	810	return 0;
811	}	811	}
812		812
813	static inline u64 intel_hsw_weight(struct pebs_record_hsw *pebs)	813	static inline u64 intel_hsw_weight(struct pebs_record_hsw *pebs)
814	{	814	{
815	if (pebs->tsx_tuning) {	815	if (pebs->tsx_tuning) {
816	union hsw_tsx_tuning tsx = { .value = pebs->tsx_tuning };	816	union hsw_tsx_tuning tsx = { .value = pebs->tsx_tuning };
817	return tsx.cycles_last_block;	817	return tsx.cycles_last_block;
818	}	818	}
819	return 0;	819	return 0;
820	}	820	}
821		821
822	static inline u64 intel_hsw_transaction(struct pebs_record_hsw *pebs)	822	static inline u64 intel_hsw_transaction(struct pebs_record_hsw *pebs)
823	{	823	{
824	u64 txn = (pebs->tsx_tuning & PEBS_HSW_TSX_FLAGS) >> 32;	824	u64 txn = (pebs->tsx_tuning & PEBS_HSW_TSX_FLAGS) >> 32;
825		825
826	/* For RTM XABORTs also log the abort code from AX */	826	/* For RTM XABORTs also log the abort code from AX */
827	if ((txn & PERF_TXN_TRANSACTION) && (pebs->ax & 1))	827	if ((txn & PERF_TXN_TRANSACTION) && (pebs->ax & 1))
828	txn \|= ((pebs->ax >> 24) & 0xff) << PERF_TXN_ABORT_SHIFT;	828	txn \|= ((pebs->ax >> 24) & 0xff) << PERF_TXN_ABORT_SHIFT;
829	return txn;	829	return txn;
830	}	830	}
831		831
832	static void __intel_pmu_pebs_event(struct perf_event *event,	832	static void __intel_pmu_pebs_event(struct perf_event *event,
833	struct pt_regs iregs, void __pebs)	833	struct pt_regs iregs, void __pebs)
834	{	834	{
835	#define PERF_X86_EVENT_PEBS_HSW_PREC \	835	#define PERF_X86_EVENT_PEBS_HSW_PREC \
836	(PERF_X86_EVENT_PEBS_ST_HSW \| \	836	(PERF_X86_EVENT_PEBS_ST_HSW \| \
837	PERF_X86_EVENT_PEBS_LD_HSW \| \	837	PERF_X86_EVENT_PEBS_LD_HSW \| \
838	PERF_X86_EVENT_PEBS_NA_HSW)	838	PERF_X86_EVENT_PEBS_NA_HSW)
839	/*	839	/*
840	* We cast to the biggest pebs_record but are careful not to	840	* We cast to the biggest pebs_record but are careful not to
841	* unconditionally access the 'extra' entries.	841	* unconditionally access the 'extra' entries.
842	*/	842	*/
843	struct cpu_hw_events *cpuc = this_cpu_ptr(&cpu_hw_events);	843	struct cpu_hw_events *cpuc = this_cpu_ptr(&cpu_hw_events);
844	struct pebs_record_hsw *pebs = __pebs;	844	struct pebs_record_hsw *pebs = __pebs;
845	struct perf_sample_data data;	845	struct perf_sample_data data;
846	struct pt_regs regs;	846	struct pt_regs regs;
847	u64 sample_type;	847	u64 sample_type;
848	int fll, fst, dsrc;	848	int fll, fst, dsrc;
849	int fl = event->hw.flags;	849	int fl = event->hw.flags;
850		850
851	if (!intel_pmu_save_and_restart(event))	851	if (!intel_pmu_save_and_restart(event))
852	return;	852	return;
853		853
854	sample_type = event->attr.sample_type;	854	sample_type = event->attr.sample_type;
855	dsrc = sample_type & PERF_SAMPLE_DATA_SRC;	855	dsrc = sample_type & PERF_SAMPLE_DATA_SRC;
856		856
857	fll = fl & PERF_X86_EVENT_PEBS_LDLAT;	857	fll = fl & PERF_X86_EVENT_PEBS_LDLAT;
858	fst = fl & (PERF_X86_EVENT_PEBS_ST \| PERF_X86_EVENT_PEBS_HSW_PREC);	858	fst = fl & (PERF_X86_EVENT_PEBS_ST \| PERF_X86_EVENT_PEBS_HSW_PREC);
859		859
860	perf_sample_data_init(&data, 0, event->hw.last_period);	860	perf_sample_data_init(&data, 0, event->hw.last_period);
861		861
862	data.period = event->hw.last_period;	862	data.period = event->hw.last_period;
863		863
864	/*	864	/*
865	* Use latency for weight (only avail with PEBS-LL)	865	* Use latency for weight (only avail with PEBS-LL)
866	*/	866	*/
867	if (fll && (sample_type & PERF_SAMPLE_WEIGHT))	867	if (fll && (sample_type & PERF_SAMPLE_WEIGHT))
868	data.weight = pebs->lat;	868	data.weight = pebs->lat;
869		869
870	/*	870	/*
871	* data.data_src encodes the data source	871	* data.data_src encodes the data source
872	*/	872	*/
873	if (dsrc) {	873	if (dsrc) {
874	u64 val = PERF_MEM_NA;	874	u64 val = PERF_MEM_NA;
875	if (fll)	875	if (fll)
876	val = load_latency_data(pebs->dse);	876	val = load_latency_data(pebs->dse);
877	else if (fst && (fl & PERF_X86_EVENT_PEBS_HSW_PREC))	877	else if (fst && (fl & PERF_X86_EVENT_PEBS_HSW_PREC))
878	val = precise_datala_hsw(event, pebs->dse);	878	val = precise_datala_hsw(event, pebs->dse);
879	else if (fst)	879	else if (fst)
880	val = precise_store_data(pebs->dse);	880	val = precise_store_data(pebs->dse);
881	data.data_src.val = val;	881	data.data_src.val = val;
882	}	882	}
883		883
884	/*	884	/*
885	* We use the interrupt regs as a base because the PEBS record	885	* We use the interrupt regs as a base because the PEBS record
886	* does not contain a full regs set, specifically it seems to	886	* does not contain a full regs set, specifically it seems to
887	* lack segment descriptors, which get used by things like	887	* lack segment descriptors, which get used by things like
888	* user_mode().	888	* user_mode().
889	*	889	*
890	* In the simple case fix up only the IP and BP,SP regs, for	890	* In the simple case fix up only the IP and BP,SP regs, for
891	* PERF_SAMPLE_IP and PERF_SAMPLE_CALLCHAIN to function properly.	891	* PERF_SAMPLE_IP and PERF_SAMPLE_CALLCHAIN to function properly.
892	* A possible PERF_SAMPLE_REGS will have to transfer all regs.	892	* A possible PERF_SAMPLE_REGS will have to transfer all regs.
893	*/	893	*/
894	regs = *iregs;	894	regs = *iregs;
895	regs.flags = pebs->flags;	895	regs.flags = pebs->flags;
896	set_linear_ip(&regs, pebs->ip);	896	set_linear_ip(&regs, pebs->ip);
897	regs.bp = pebs->bp;	897	regs.bp = pebs->bp;
898	regs.sp = pebs->sp;	898	regs.sp = pebs->sp;
899		899
900	if (sample_type & PERF_SAMPLE_REGS_INTR) {	900	if (sample_type & PERF_SAMPLE_REGS_INTR) {
901	regs.ax = pebs->ax;	901	regs.ax = pebs->ax;
902	regs.bx = pebs->bx;	902	regs.bx = pebs->bx;
903	regs.cx = pebs->cx;	903	regs.cx = pebs->cx;
904	regs.dx = pebs->dx;	904	regs.dx = pebs->dx;
905	regs.si = pebs->si;	905	regs.si = pebs->si;
906	regs.di = pebs->di;	906	regs.di = pebs->di;
907	regs.bp = pebs->bp;	907	regs.bp = pebs->bp;
908	regs.sp = pebs->sp;	908	regs.sp = pebs->sp;
909		909
910	regs.flags = pebs->flags;	910	regs.flags = pebs->flags;
911	#ifndef CONFIG_X86_32	911	#ifndef CONFIG_X86_32
912	regs.r8 = pebs->r8;	912	regs.r8 = pebs->r8;
913	regs.r9 = pebs->r9;	913	regs.r9 = pebs->r9;
914	regs.r10 = pebs->r10;	914	regs.r10 = pebs->r10;
915	regs.r11 = pebs->r11;	915	regs.r11 = pebs->r11;
916	regs.r12 = pebs->r12;	916	regs.r12 = pebs->r12;
917	regs.r13 = pebs->r13;	917	regs.r13 = pebs->r13;
918	regs.r14 = pebs->r14;	918	regs.r14 = pebs->r14;
919	regs.r15 = pebs->r15;	919	regs.r15 = pebs->r15;
920	#endif	920	#endif
921	}	921	}
922		922
923	if (event->attr.precise_ip > 1 && x86_pmu.intel_cap.pebs_format >= 2) {	923	if (event->attr.precise_ip > 1 && x86_pmu.intel_cap.pebs_format >= 2) {
924	regs.ip = pebs->real_ip;	924	regs.ip = pebs->real_ip;
925	regs.flags \|= PERF_EFLAGS_EXACT;	925	regs.flags \|= PERF_EFLAGS_EXACT;
926	} else if (event->attr.precise_ip > 1 && intel_pmu_pebs_fixup_ip(&regs))	926	} else if (event->attr.precise_ip > 1 && intel_pmu_pebs_fixup_ip(&regs))
927	regs.flags \|= PERF_EFLAGS_EXACT;	927	regs.flags \|= PERF_EFLAGS_EXACT;
928	else	928	else
929	regs.flags &= ~PERF_EFLAGS_EXACT;	929	regs.flags &= ~PERF_EFLAGS_EXACT;
930		930
931	if ((sample_type & PERF_SAMPLE_ADDR) &&	931	if ((sample_type & PERF_SAMPLE_ADDR) &&
932	x86_pmu.intel_cap.pebs_format >= 1)	932	x86_pmu.intel_cap.pebs_format >= 1)
933	data.addr = pebs->dla;	933	data.addr = pebs->dla;
934		934
935	if (x86_pmu.intel_cap.pebs_format >= 2) {	935	if (x86_pmu.intel_cap.pebs_format >= 2) {
936	/* Only set the TSX weight when no memory weight. */	936	/* Only set the TSX weight when no memory weight. */
937	if ((sample_type & PERF_SAMPLE_WEIGHT) && !fll)	937	if ((sample_type & PERF_SAMPLE_WEIGHT) && !fll)
938	data.weight = intel_hsw_weight(pebs);	938	data.weight = intel_hsw_weight(pebs);
939		939
940	if (sample_type & PERF_SAMPLE_TRANSACTION)	940	if (sample_type & PERF_SAMPLE_TRANSACTION)
941	data.txn = intel_hsw_transaction(pebs);	941	data.txn = intel_hsw_transaction(pebs);
942	}	942	}
943		943
944	if (has_branch_stack(event))	944	if (has_branch_stack(event))
945	data.br_stack = &cpuc->lbr_stack;	945	data.br_stack = &cpuc->lbr_stack;
946		946
947	if (perf_event_overflow(event, &data, &regs))	947	if (perf_event_overflow(event, &data, &regs))
948	x86_pmu_stop(event, 0);	948	x86_pmu_stop(event, 0);
949	}	949	}
950		950
951	static void intel_pmu_drain_pebs_core(struct pt_regs *iregs)	951	static void intel_pmu_drain_pebs_core(struct pt_regs *iregs)
952	{	952	{
953	struct cpu_hw_events *cpuc = this_cpu_ptr(&cpu_hw_events);	953	struct cpu_hw_events *cpuc = this_cpu_ptr(&cpu_hw_events);
954	struct debug_store *ds = cpuc->ds;	954	struct debug_store *ds = cpuc->ds;
955	struct perf_event event = cpuc->events[0]; / PMC0 only */	955	struct perf_event event = cpuc->events[0]; / PMC0 only */
956	struct pebs_record_core at, top;	956	struct pebs_record_core at, top;
957	int n;	957	int n;
958		958
959	if (!x86_pmu.pebs_active)	959	if (!x86_pmu.pebs_active)
960	return;	960	return;
961		961
962	at = (struct pebs_record_core *)(unsigned long)ds->pebs_buffer_base;	962	at = (struct pebs_record_core *)(unsigned long)ds->pebs_buffer_base;
963	top = (struct pebs_record_core *)(unsigned long)ds->pebs_index;	963	top = (struct pebs_record_core *)(unsigned long)ds->pebs_index;
964		964
965	/*	965	/*
966	* Whatever else happens, drain the thing	966	* Whatever else happens, drain the thing
967	*/	967	*/
968	ds->pebs_index = ds->pebs_buffer_base;	968	ds->pebs_index = ds->pebs_buffer_base;
969		969
970	if (!test_bit(0, cpuc->active_mask))	970	if (!test_bit(0, cpuc->active_mask))
971	return;	971	return;
972		972
973	WARN_ON_ONCE(!event);	973	WARN_ON_ONCE(!event);
974		974
975	if (!event->attr.precise_ip)	975	if (!event->attr.precise_ip)
976	return;	976	return;
977		977
978	n = top - at;	978	n = top - at;
979	if (n <= 0)	979	if (n <= 0)
980	return;	980	return;
981		981
982	/*	982	/*
983	* Should not happen, we program the threshold at 1 and do not	983	* Should not happen, we program the threshold at 1 and do not
984	* set a reset value.	984	* set a reset value.
985	*/	985	*/
986	WARN_ONCE(n > 1, "bad leftover pebs %d\n", n);	986	WARN_ONCE(n > 1, "bad leftover pebs %d\n", n);
987	at += n - 1;	987	at += n - 1;
988		988
989	__intel_pmu_pebs_event(event, iregs, at);	989	__intel_pmu_pebs_event(event, iregs, at);
990	}	990	}
991		991
992	static void intel_pmu_drain_pebs_nhm(struct pt_regs *iregs)	992	static void intel_pmu_drain_pebs_nhm(struct pt_regs *iregs)
993	{	993	{
994	struct cpu_hw_events *cpuc = this_cpu_ptr(&cpu_hw_events);	994	struct cpu_hw_events *cpuc = this_cpu_ptr(&cpu_hw_events);
995	struct debug_store *ds = cpuc->ds;	995	struct debug_store *ds = cpuc->ds;
996	struct perf_event *event = NULL;	996	struct perf_event *event = NULL;
997	void at, top;	997	void at, top;
998	u64 status = 0;	998	u64 status = 0;
999	int bit;	999	int bit;
1000		1000
1001	if (!x86_pmu.pebs_active)	1001	if (!x86_pmu.pebs_active)
1002	return;	1002	return;
1003		1003
1004	at = (struct pebs_record_nhm *)(unsigned long)ds->pebs_buffer_base;	1004	at = (struct pebs_record_nhm *)(unsigned long)ds->pebs_buffer_base;
1005	top = (struct pebs_record_nhm *)(unsigned long)ds->pebs_index;	1005	top = (struct pebs_record_nhm *)(unsigned long)ds->pebs_index;
1006		1006
1007	ds->pebs_index = ds->pebs_buffer_base;	1007	ds->pebs_index = ds->pebs_buffer_base;
1008		1008
1009	if (unlikely(at > top))	1009	if (unlikely(at > top))
1010	return;	1010	return;
1011		1011
1012	/*	1012	/*
1013	* Should not happen, we program the threshold at 1 and do not	1013	* Should not happen, we program the threshold at 1 and do not
1014	* set a reset value.	1014	* set a reset value.
1015	*/	1015	*/
1016	WARN_ONCE(top - at > x86_pmu.max_pebs_events * x86_pmu.pebs_record_size,	1016	WARN_ONCE(top - at > x86_pmu.max_pebs_events * x86_pmu.pebs_record_size,
1017	"Unexpected number of pebs records %ld\n",	1017	"Unexpected number of pebs records %ld\n",
1018	(long)(top - at) / x86_pmu.pebs_record_size);	1018	(long)(top - at) / x86_pmu.pebs_record_size);
1019		1019
1020	for (; at < top; at += x86_pmu.pebs_record_size) {	1020	for (; at < top; at += x86_pmu.pebs_record_size) {
1021	struct pebs_record_nhm *p = at;	1021	struct pebs_record_nhm *p = at;
1022		1022
1023	for_each_set_bit(bit, (unsigned long *)&p->status,	1023	for_each_set_bit(bit, (unsigned long *)&p->status,
1024	x86_pmu.max_pebs_events) {	1024	x86_pmu.max_pebs_events) {
1025	event = cpuc->events[bit];	1025	event = cpuc->events[bit];
1026	if (!test_bit(bit, cpuc->active_mask))	1026	if (!test_bit(bit, cpuc->active_mask))
1027	continue;	1027	continue;
1028		1028
1029	WARN_ON_ONCE(!event);	1029	WARN_ON_ONCE(!event);
1030		1030
1031	if (!event->attr.precise_ip)	1031	if (!event->attr.precise_ip)
1032	continue;	1032	continue;
1033		1033
1034	if (__test_and_set_bit(bit, (unsigned long *)&status))	1034	if (__test_and_set_bit(bit, (unsigned long *)&status))
1035	continue;	1035	continue;
1036		1036
1037	break;	1037	break;
1038	}	1038	}
1039		1039
1040	if (!event \|\| bit >= x86_pmu.max_pebs_events)	1040	if (!event \|\| bit >= x86_pmu.max_pebs_events)
1041	continue;	1041	continue;
1042		1042
1043	__intel_pmu_pebs_event(event, iregs, at);	1043	__intel_pmu_pebs_event(event, iregs, at);
1044	}	1044	}
1045	}	1045	}
1046		1046
1047	/*	1047	/*
1048	* BTS, PEBS probe and setup	1048	* BTS, PEBS probe and setup
1049	*/	1049	*/
1050		1050
1051	void __init intel_ds_init(void)	1051	void __init intel_ds_init(void)
1052	{	1052	{
1053	/*	1053	/*
1054	* No support for 32bit formats	1054	* No support for 32bit formats
1055	*/	1055	*/
1056	if (!boot_cpu_has(X86_FEATURE_DTES64))	1056	if (!boot_cpu_has(X86_FEATURE_DTES64))
1057	return;	1057	return;
1058		1058
1059	x86_pmu.bts = boot_cpu_has(X86_FEATURE_BTS);	1059	x86_pmu.bts = boot_cpu_has(X86_FEATURE_BTS);
1060	x86_pmu.pebs = boot_cpu_has(X86_FEATURE_PEBS);	1060	x86_pmu.pebs = boot_cpu_has(X86_FEATURE_PEBS);
1061	if (x86_pmu.pebs) {	1061	if (x86_pmu.pebs) {
1062	char pebs_type = x86_pmu.intel_cap.pebs_trap ? '+' : '-';	1062	char pebs_type = x86_pmu.intel_cap.pebs_trap ? '+' : '-';
1063	int format = x86_pmu.intel_cap.pebs_format;	1063	int format = x86_pmu.intel_cap.pebs_format;
1064		1064
1065	switch (format) {	1065	switch (format) {
1066	case 0:	1066	case 0:
1067	printk(KERN_CONT "PEBS fmt0%c, ", pebs_type);	1067	printk(KERN_CONT "PEBS fmt0%c, ", pebs_type);
1068	x86_pmu.pebs_record_size = sizeof(struct pebs_record_core);	1068	x86_pmu.pebs_record_size = sizeof(struct pebs_record_core);
1069	x86_pmu.drain_pebs = intel_pmu_drain_pebs_core;	1069	x86_pmu.drain_pebs = intel_pmu_drain_pebs_core;
1070	break;	1070	break;
1071		1071
1072	case 1:	1072	case 1:
1073	printk(KERN_CONT "PEBS fmt1%c, ", pebs_type);	1073	printk(KERN_CONT "PEBS fmt1%c, ", pebs_type);
1074	x86_pmu.pebs_record_size = sizeof(struct pebs_record_nhm);	1074	x86_pmu.pebs_record_size = sizeof(struct pebs_record_nhm);
1075	x86_pmu.drain_pebs = intel_pmu_drain_pebs_nhm;	1075	x86_pmu.drain_pebs = intel_pmu_drain_pebs_nhm;
1076	break;	1076	break;
1077		1077
1078	case 2:	1078	case 2:
1079	pr_cont("PEBS fmt2%c, ", pebs_type);	1079	pr_cont("PEBS fmt2%c, ", pebs_type);
1080	x86_pmu.pebs_record_size = sizeof(struct pebs_record_hsw);	1080	x86_pmu.pebs_record_size = sizeof(struct pebs_record_hsw);
1081	x86_pmu.drain_pebs = intel_pmu_drain_pebs_nhm;	1081	x86_pmu.drain_pebs = intel_pmu_drain_pebs_nhm;
1082	break;	1082	break;
1083		1083
1084	default:	1084	default:
1085	printk(KERN_CONT "no PEBS fmt%d%c, ", format, pebs_type);	1085	printk(KERN_CONT "no PEBS fmt%d%c, ", format, pebs_type);
1086	x86_pmu.pebs = 0;	1086	x86_pmu.pebs = 0;
1087	}	1087	}
1088	}	1088	}
1089	}	1089	}
1090		1090
1091	void perf_restore_debug_store(void)	1091	void perf_restore_debug_store(void)
1092	{	1092	{
1093	struct debug_store *ds = __this_cpu_read(cpu_hw_events.ds);	1093	struct debug_store *ds = __this_cpu_read(cpu_hw_events.ds);
1094		1094
1095	if (!x86_pmu.bts && !x86_pmu.pebs)	1095	if (!x86_pmu.bts && !x86_pmu.pebs)
1096	return;	1096	return;
1097		1097
1098	wrmsrl(MSR_IA32_DS_AREA, (unsigned long)ds);	1098	wrmsrl(MSR_IA32_DS_AREA, (unsigned long)ds);
1099	}	1099	}
1100		1100

arch/x86/kernel/cpu/perf_event_intel_rapl.c

Diff comments View file @ 59b2858

 /*
  * perf_event_intel_rapl.c: support Intel RAPL energy consumption counters
  * Copyright (C) 2013 Google, Inc., Stephane Eranian
  *
  * Intel RAPL interface is specified in the IA-32 Manual Vol3b
  * section 14.7.1 (September 2013)
  *
  * RAPL provides more controls than just reporting energy consumption
  * however here we only expose the 3 energy consumption free running
  * counters (pp0, pkg, dram).
  *
  * Each of those counters increments in a power unit defined by the
  * RAPL_POWER_UNIT MSR. On SandyBridge, this unit is 1/(2^16) Joules
  * but it can vary.
  *
  * Counter to rapl events mappings:
  *
  *  pp0 counter: consumption of all physical cores (power plane 0)
  * 	  event: rapl_energy_cores
  *    perf code: 0x1
  *
  *  pkg counter: consumption of the whole processor package
  *	  event: rapl_energy_pkg
  *    perf code: 0x2
  *
  * dram counter: consumption of the dram domain (servers only)
  *	  event: rapl_energy_dram
  *    perf code: 0x3
  *
  * dram counter: consumption of the builtin-gpu domain (client only)
  *	  event: rapl_energy_gpu
  *    perf code: 0x4
  *
  * We manage those counters as free running (read-only). They may be
  * use simultaneously by other tools, such as turbostat.
  *
  * The events only support system-wide mode counting. There is no
  * sampling support because it does not make sense and is not
  * supported by the RAPL hardware.
  *
  * Because we want to avoid floating-point operations in the kernel,
  * the events are all reported in fixed point arithmetic (32.32).
  * Tools must adjust the counts to convert them to Watts using
  * the duration of the measurement. Tools may use a function such as
  * ldexp(raw_count, -32);
  */
 #include <linux/module.h>
 #include <linux/slab.h>
 #include <linux/perf_event.h>
 #include <asm/cpu_device_id.h>
 #include "perf_event.h"
 /*
  * RAPL energy status counters
  */
 #define RAPL_IDX_PP0_NRG_STAT	0	/* all cores */
 #define INTEL_RAPL_PP0		0x1	/* pseudo-encoding */
 #define RAPL_IDX_PKG_NRG_STAT	1	/* entire package */
 #define INTEL_RAPL_PKG		0x2	/* pseudo-encoding */
 #define RAPL_IDX_RAM_NRG_STAT	2	/* DRAM */
 #define INTEL_RAPL_RAM		0x3	/* pseudo-encoding */
 #define RAPL_IDX_PP1_NRG_STAT	3	/* gpu */
 #define INTEL_RAPL_PP1		0x4	/* pseudo-encoding */
 /* Clients have PP0, PKG */
 #define RAPL_IDX_CLN	(1<<RAPL_IDX_PP0_NRG_STAT|\
 			 1<<RAPL_IDX_PKG_NRG_STAT|\
 			 1<<RAPL_IDX_PP1_NRG_STAT)
 /* Servers have PP0, PKG, RAM */
 #define RAPL_IDX_SRV	(1<<RAPL_IDX_PP0_NRG_STAT|\
 			 1<<RAPL_IDX_PKG_NRG_STAT|\
 			 1<<RAPL_IDX_RAM_NRG_STAT)
 /* Servers have PP0, PKG, RAM, PP1 */
 #define RAPL_IDX_HSW	(1<<RAPL_IDX_PP0_NRG_STAT|\
 			 1<<RAPL_IDX_PKG_NRG_STAT|\
 			 1<<RAPL_IDX_RAM_NRG_STAT|\
 			 1<<RAPL_IDX_PP1_NRG_STAT)
 /*
  * event code: LSB 8 bits, passed in attr->config
  * any other bit is reserved
  */
 #define RAPL_EVENT_MASK	0xFFULL
 #define DEFINE_RAPL_FORMAT_ATTR(_var, _name, _format)		\
 static ssize_t __rapl_##_var##_show(struct kobject *kobj,	\
 				struct kobj_attribute *attr,	\
 				char *page)			\
 {								\
 	BUILD_BUG_ON(sizeof(_format) >= PAGE_SIZE);		\
 	return sprintf(page, _format "\n");			\
 }								\
 static struct kobj_attribute format_attr_##_var =		\
 	__ATTR(_name, 0444, __rapl_##_var##_show, NULL)
 #define RAPL_EVENT_DESC(_name, _config)				\
 {								\
 	.attr	= __ATTR(_name, 0444, rapl_event_show, NULL),	\
 	.config	= _config,					\
 }
 #define RAPL_CNTR_WIDTH 32 /* 32-bit rapl counters */
+#define RAPL_EVENT_ATTR_STR(_name, v, str)				\
+static struct perf_pmu_events_attr event_attr_##v = {			\
+	.attr		= __ATTR(_name, 0444, rapl_sysfs_show, NULL),	\
+	.id		= 0,						\
+	.event_str	= str,						\
+};
 struct rapl_pmu {
 	spinlock_t	 lock;
 	int		 hw_unit;  /* 1/2^hw_unit Joule */
 	int		 n_active; /* number of active events */
 	struct list_head active_list;
 	struct pmu	 *pmu; /* pointer to rapl_pmu_class */
 	ktime_t		 timer_interval; /* in ktime_t unit */
 	struct hrtimer   hrtimer;
 };
 static struct pmu rapl_pmu_class;
 static cpumask_t rapl_cpu_mask;
 static int rapl_cntr_mask;
 static DEFINE_PER_CPU(struct rapl_pmu *, rapl_pmu);
 static DEFINE_PER_CPU(struct rapl_pmu *, rapl_pmu_to_free);
 static inline u64 rapl_read_counter(struct perf_event *event)
 {
 	u64 raw;
 	rdmsrl(event->hw.event_base, raw);
 	return raw;
 }
 static inline u64 rapl_scale(u64 v)
 {
 	/*
 	 * scale delta to smallest unit (1/2^32)
 	 * users must then scale back: count * 1/(1e9*2^32) to get Joules
 	 * or use ldexp(count, -32).
 	 * Watts = Joules/Time delta
 	 */
 	return v << (32 - __this_cpu_read(rapl_pmu->hw_unit));
 }
 static u64 rapl_event_update(struct perf_event *event)
 {
 	struct hw_perf_event *hwc = &event->hw;
 	u64 prev_raw_count, new_raw_count;
 	s64 delta, sdelta;
 	int shift = RAPL_CNTR_WIDTH;
 again:
 	prev_raw_count = local64_read(&hwc->prev_count);
 	rdmsrl(event->hw.event_base, new_raw_count);
 	if (local64_cmpxchg(&hwc->prev_count, prev_raw_count,
 			    new_raw_count) != prev_raw_count) {
 		cpu_relax();
 		goto again;
 	}
 	/*
 	 * Now we have the new raw value and have updated the prev
 	 * timestamp already. We can now calculate the elapsed delta
 	 * (event-)time and add that to the generic event.
 	 *
 	 * Careful, not all hw sign-extends above the physical width
 	 * of the count.
 	 */
 	delta = (new_raw_count << shift) - (prev_raw_count << shift);
 	delta >>= shift;
 	sdelta = rapl_scale(delta);
 	local64_add(sdelta, &event->count);
 	return new_raw_count;
 }
 static void rapl_start_hrtimer(struct rapl_pmu *pmu)
 {
 	__hrtimer_start_range_ns(&pmu->hrtimer,
 			pmu->timer_interval, 0,
 			HRTIMER_MODE_REL_PINNED, 0);
 }
 static void rapl_stop_hrtimer(struct rapl_pmu *pmu)
 {
 	hrtimer_cancel(&pmu->hrtimer);
 }
 static enum hrtimer_restart rapl_hrtimer_handle(struct hrtimer *hrtimer)
 {
 	struct rapl_pmu *pmu = __this_cpu_read(rapl_pmu);
 	struct perf_event *event;
 	unsigned long flags;
 	if (!pmu->n_active)
 		return HRTIMER_NORESTART;
 	spin_lock_irqsave(&pmu->lock, flags);
 	list_for_each_entry(event, &pmu->active_list, active_entry) {
 		rapl_event_update(event);
 	}
 	spin_unlock_irqrestore(&pmu->lock, flags);
 	hrtimer_forward_now(hrtimer, pmu->timer_interval);
 	return HRTIMER_RESTART;
 }
 static void rapl_hrtimer_init(struct rapl_pmu *pmu)
 {
 	struct hrtimer *hr = &pmu->hrtimer;
 	hrtimer_init(hr, CLOCK_MONOTONIC, HRTIMER_MODE_REL);
 	hr->function = rapl_hrtimer_handle;
 }
 static void __rapl_pmu_event_start(struct rapl_pmu *pmu,
 				   struct perf_event *event)
 {
 	if (WARN_ON_ONCE(!(event->hw.state & PERF_HES_STOPPED)))
 		return;
 	event->hw.state = 0;
 	list_add_tail(&event->active_entry, &pmu->active_list);
 	local64_set(&event->hw.prev_count, rapl_read_counter(event));
 	pmu->n_active++;
 	if (pmu->n_active == 1)
 		rapl_start_hrtimer(pmu);
 }
 static void rapl_pmu_event_start(struct perf_event *event, int mode)
 {
 	struct rapl_pmu *pmu = __this_cpu_read(rapl_pmu);
 	unsigned long flags;
 	spin_lock_irqsave(&pmu->lock, flags);
 	__rapl_pmu_event_start(pmu, event);
 	spin_unlock_irqrestore(&pmu->lock, flags);
 }
 static void rapl_pmu_event_stop(struct perf_event *event, int mode)
 {
 	struct rapl_pmu *pmu = __this_cpu_read(rapl_pmu);
 	struct hw_perf_event *hwc = &event->hw;
 	unsigned long flags;
 	spin_lock_irqsave(&pmu->lock, flags);
 	/* mark event as deactivated and stopped */
 	if (!(hwc->state & PERF_HES_STOPPED)) {
 		WARN_ON_ONCE(pmu->n_active <= 0);
 		pmu->n_active--;
 		if (pmu->n_active == 0)
 			rapl_stop_hrtimer(pmu);
 		list_del(&event->active_entry);
 		WARN_ON_ONCE(hwc->state & PERF_HES_STOPPED);
 		hwc->state |= PERF_HES_STOPPED;
 	}
 	/* check if update of sw counter is necessary */
 	if ((mode & PERF_EF_UPDATE) && !(hwc->state & PERF_HES_UPTODATE)) {
 		/*
 		 * Drain the remaining delta count out of a event
 		 * that we are disabling:
 		 */
 		rapl_event_update(event);
 		hwc->state |= PERF_HES_UPTODATE;
 	}
 	spin_unlock_irqrestore(&pmu->lock, flags);
 }
 static int rapl_pmu_event_add(struct perf_event *event, int mode)
 {
 	struct rapl_pmu *pmu = __this_cpu_read(rapl_pmu);
 	struct hw_perf_event *hwc = &event->hw;
 	unsigned long flags;
 	spin_lock_irqsave(&pmu->lock, flags);
 	hwc->state = PERF_HES_UPTODATE | PERF_HES_STOPPED;
 	if (mode & PERF_EF_START)
 		__rapl_pmu_event_start(pmu, event);
 	spin_unlock_irqrestore(&pmu->lock, flags);
 	return 0;
 }
 static void rapl_pmu_event_del(struct perf_event *event, int flags)
 {
 	rapl_pmu_event_stop(event, PERF_EF_UPDATE);
 }
 static int rapl_pmu_event_init(struct perf_event *event)
 {
 	u64 cfg = event->attr.config & RAPL_EVENT_MASK;
 	int bit, msr, ret = 0;
 	/* only look at RAPL events */
 	if (event->attr.type != rapl_pmu_class.type)
 		return -ENOENT;
 	/* check only supported bits are set */
 	if (event->attr.config & ~RAPL_EVENT_MASK)
 		return -EINVAL;
 	/*
 	 * check event is known (determines counter)
 	 */
 	switch (cfg) {
 	case INTEL_RAPL_PP0:
 		bit = RAPL_IDX_PP0_NRG_STAT;
 		msr = MSR_PP0_ENERGY_STATUS;
 		break;
 	case INTEL_RAPL_PKG:
 		bit = RAPL_IDX_PKG_NRG_STAT;
 		msr = MSR_PKG_ENERGY_STATUS;
 		break;
 	case INTEL_RAPL_RAM:
 		bit = RAPL_IDX_RAM_NRG_STAT;
 		msr = MSR_DRAM_ENERGY_STATUS;
 		break;
 	case INTEL_RAPL_PP1:
 		bit = RAPL_IDX_PP1_NRG_STAT;
 		msr = MSR_PP1_ENERGY_STATUS;
 		break;
 	default:
 		return -EINVAL;
 	}
 	/* check event supported */
 	if (!(rapl_cntr_mask & (1 << bit)))
 		return -EINVAL;
 	/* unsupported modes and filters */
 	if (event->attr.exclude_user   ||
 	    event->attr.exclude_kernel ||
 	    event->attr.exclude_hv     ||
 	    event->attr.exclude_idle   ||
 	    event->attr.exclude_host   ||
 	    event->attr.exclude_guest  ||
 	    event->attr.sample_period) /* no sampling */
 		return -EINVAL;
 	/* must be done before validate_group */
 	event->hw.event_base = msr;
 	event->hw.config = cfg;
 	event->hw.idx = bit;
 	return ret;
 }
 static void rapl_pmu_event_read(struct perf_event *event)
 {
 	rapl_event_update(event);
 }
 static ssize_t rapl_get_attr_cpumask(struct device *dev,
 				struct device_attribute *attr, char *buf)
 {
 	return cpumap_print_to_pagebuf(true, buf, &rapl_cpu_mask);
 }
 static DEVICE_ATTR(cpumask, S_IRUGO, rapl_get_attr_cpumask, NULL);
 static struct attribute *rapl_pmu_attrs[] = {
 	&dev_attr_cpumask.attr,
 	NULL,
 };
 static struct attribute_group rapl_pmu_attr_group = {
 	.attrs = rapl_pmu_attrs,
 };
-EVENT_ATTR_STR(energy-cores, rapl_cores, "event=0x01");
+static ssize_t rapl_sysfs_show(struct device *dev,
-EVENT_ATTR_STR(energy-pkg  ,   rapl_pkg, "event=0x02");
+			       struct device_attribute *attr,
-EVENT_ATTR_STR(energy-ram  ,   rapl_ram, "event=0x03");
+			       char *page)
-EVENT_ATTR_STR(energy-gpu  ,   rapl_gpu, "event=0x04");
+{
+	struct perf_pmu_events_attr *pmu_attr = \
+		container_of(attr, struct perf_pmu_events_attr, attr);
-EVENT_ATTR_STR(energy-cores.unit, rapl_cores_unit, "Joules");
+	if (pmu_attr->event_str)
-EVENT_ATTR_STR(energy-pkg.unit  ,   rapl_pkg_unit, "Joules");
+		return sprintf(page, "%s", pmu_attr->event_str);
-EVENT_ATTR_STR(energy-ram.unit  ,   rapl_ram_unit, "Joules");
-EVENT_ATTR_STR(energy-gpu.unit  ,   rapl_gpu_unit, "Joules");
+	return 0;
+}
+RAPL_EVENT_ATTR_STR(energy-cores, rapl_cores, "event=0x01");
+RAPL_EVENT_ATTR_STR(energy-pkg  ,   rapl_pkg, "event=0x02");
+RAPL_EVENT_ATTR_STR(energy-ram  ,   rapl_ram, "event=0x03");
+RAPL_EVENT_ATTR_STR(energy-gpu  ,   rapl_gpu, "event=0x04");
+RAPL_EVENT_ATTR_STR(energy-cores.unit, rapl_cores_unit, "Joules");
+RAPL_EVENT_ATTR_STR(energy-pkg.unit  ,   rapl_pkg_unit, "Joules");
+RAPL_EVENT_ATTR_STR(energy-ram.unit  ,   rapl_ram_unit, "Joules");
+RAPL_EVENT_ATTR_STR(energy-gpu.unit  ,   rapl_gpu_unit, "Joules");
 /*
  * we compute in 0.23 nJ increments regardless of MSR
  */
-EVENT_ATTR_STR(energy-cores.scale, rapl_cores_scale, "2.3283064365386962890625e-10");
+RAPL_EVENT_ATTR_STR(energy-cores.scale, rapl_cores_scale, "2.3283064365386962890625e-10");
-EVENT_ATTR_STR(energy-pkg.scale,     rapl_pkg_scale, "2.3283064365386962890625e-10");
+RAPL_EVENT_ATTR_STR(energy-pkg.scale,     rapl_pkg_scale, "2.3283064365386962890625e-10");
-EVENT_ATTR_STR(energy-ram.scale,     rapl_ram_scale, "2.3283064365386962890625e-10");
+RAPL_EVENT_ATTR_STR(energy-ram.scale,     rapl_ram_scale, "2.3283064365386962890625e-10");
-EVENT_ATTR_STR(energy-gpu.scale,     rapl_gpu_scale, "2.3283064365386962890625e-10");
+RAPL_EVENT_ATTR_STR(energy-gpu.scale,     rapl_gpu_scale, "2.3283064365386962890625e-10");
 static struct attribute *rapl_events_srv_attr[] = {
 	EVENT_PTR(rapl_cores),
 	EVENT_PTR(rapl_pkg),
 	EVENT_PTR(rapl_ram),
 	EVENT_PTR(rapl_cores_unit),
 	EVENT_PTR(rapl_pkg_unit),
 	EVENT_PTR(rapl_ram_unit),
 	EVENT_PTR(rapl_cores_scale),
 	EVENT_PTR(rapl_pkg_scale),
 	EVENT_PTR(rapl_ram_scale),
 	NULL,
 };
 static struct attribute *rapl_events_cln_attr[] = {
 	EVENT_PTR(rapl_cores),
 	EVENT_PTR(rapl_pkg),
 	EVENT_PTR(rapl_gpu),
 	EVENT_PTR(rapl_cores_unit),
 	EVENT_PTR(rapl_pkg_unit),
 	EVENT_PTR(rapl_gpu_unit),
 	EVENT_PTR(rapl_cores_scale),
 	EVENT_PTR(rapl_pkg_scale),
 	EVENT_PTR(rapl_gpu_scale),
 	NULL,
 };
 static struct attribute *rapl_events_hsw_attr[] = {
 	EVENT_PTR(rapl_cores),
 	EVENT_PTR(rapl_pkg),
 	EVENT_PTR(rapl_gpu),
 	EVENT_PTR(rapl_ram),
 	EVENT_PTR(rapl_cores_unit),
 	EVENT_PTR(rapl_pkg_unit),
 	EVENT_PTR(rapl_gpu_unit),
 	EVENT_PTR(rapl_ram_unit),
 	EVENT_PTR(rapl_cores_scale),
 	EVENT_PTR(rapl_pkg_scale),
 	EVENT_PTR(rapl_gpu_scale),
 	EVENT_PTR(rapl_ram_scale),
 	NULL,
 };
 static struct attribute_group rapl_pmu_events_group = {
 	.name = "events",
 	.attrs = NULL, /* patched at runtime */
 };
 DEFINE_RAPL_FORMAT_ATTR(event, event, "config:0-7");
 static struct attribute *rapl_formats_attr[] = {
 	&format_attr_event.attr,
 	NULL,
 };
 static struct attribute_group rapl_pmu_format_group = {
 	.name = "format",
 	.attrs = rapl_formats_attr,
 };
 const struct attribute_group *rapl_attr_groups[] = {
 	&rapl_pmu_attr_group,
 	&rapl_pmu_format_group,
 	&rapl_pmu_events_group,
 	NULL,
 };
 static struct pmu rapl_pmu_class = {
 	.attr_groups	= rapl_attr_groups,
 	.task_ctx_nr	= perf_invalid_context, /* system-wide only */
 	.event_init	= rapl_pmu_event_init,
 	.add		= rapl_pmu_event_add, /* must have */
 	.del		= rapl_pmu_event_del, /* must have */
 	.start		= rapl_pmu_event_start,
 	.stop		= rapl_pmu_event_stop,
 	.read		= rapl_pmu_event_read,
 };
 static void rapl_cpu_exit(int cpu)
 {
 	struct rapl_pmu *pmu = per_cpu(rapl_pmu, cpu);
 	int i, phys_id = topology_physical_package_id(cpu);
 	int target = -1;
 	/* find a new cpu on same package */
 	for_each_online_cpu(i) {
 		if (i == cpu)
 			continue;
 		if (phys_id == topology_physical_package_id(i)) {
 			target = i;
 			break;
 		}
 	}
 	/*
 	 * clear cpu from cpumask
 	 * if was set in cpumask and still some cpu on package,
 	 * then move to new cpu
 	 */
 	if (cpumask_test_and_clear_cpu(cpu, &rapl_cpu_mask) && target >= 0)
 		cpumask_set_cpu(target, &rapl_cpu_mask);
 	WARN_ON(cpumask_empty(&rapl_cpu_mask));
 	/*
 	 * migrate events and context to new cpu
 	 */
 	if (target >= 0)
 		perf_pmu_migrate_context(pmu->pmu, cpu, target);
 	/* cancel overflow polling timer for CPU */
 	rapl_stop_hrtimer(pmu);
 }
 static void rapl_cpu_init(int cpu)
 {
 	int i, phys_id = topology_physical_package_id(cpu);
 	/* check if phys_is is already covered */
 	for_each_cpu(i, &rapl_cpu_mask) {
 		if (phys_id == topology_physical_package_id(i))
 			return;
 	}
 	/* was not found, so add it */
 	cpumask_set_cpu(cpu, &rapl_cpu_mask);
 }
 static int rapl_cpu_prepare(int cpu)
 {
 	struct rapl_pmu *pmu = per_cpu(rapl_pmu, cpu);
 	int phys_id = topology_physical_package_id(cpu);
 	u64 ms;
 	u64 msr_rapl_power_unit_bits;
 	if (pmu)
 		return 0;
 	if (phys_id < 0)
 		return -1;
 	/* protect rdmsrl() to handle virtualization */
 	if (rdmsrl_safe(MSR_RAPL_POWER_UNIT, &msr_rapl_power_unit_bits))
 		return -1;
 	pmu = kzalloc_node(sizeof(*pmu), GFP_KERNEL, cpu_to_node(cpu));
 	if (!pmu)
 		return -1;
 	spin_lock_init(&pmu->lock);
 	INIT_LIST_HEAD(&pmu->active_list);
 	/*
 	 * grab power unit as: 1/2^unit Joules
 	 *
 	 * we cache in local PMU instance
 	 */
 	pmu->hw_unit = (msr_rapl_power_unit_bits >> 8) & 0x1FULL;
 	pmu->pmu = &rapl_pmu_class;
 	/*
 	 * use reference of 200W for scaling the timeout
 	 * to avoid missing counter overflows.
 	 * 200W = 200 Joules/sec
 	 * divide interval by 2 to avoid lockstep (2 * 100)
 	 * if hw unit is 32, then we use 2 ms 1/200/2
 	 */
 	if (pmu->hw_unit < 32)
 		ms = (1000 / (2 * 100)) * (1ULL << (32 - pmu->hw_unit - 1));
 	else
 		ms = 2;
 	pmu->timer_interval = ms_to_ktime(ms);
 	rapl_hrtimer_init(pmu);
 	/* set RAPL pmu for this cpu for now */
 	per_cpu(rapl_pmu, cpu) = pmu;
 	per_cpu(rapl_pmu_to_free, cpu) = NULL;
 	return 0;
 }
 static void rapl_cpu_kfree(int cpu)
 {
 	struct rapl_pmu *pmu = per_cpu(rapl_pmu_to_free, cpu);
 	kfree(pmu);
 	per_cpu(rapl_pmu_to_free, cpu) = NULL;
 }
 static int rapl_cpu_dying(int cpu)
 {
 	struct rapl_pmu *pmu = per_cpu(rapl_pmu, cpu);
 	if (!pmu)
 		return 0;
 	per_cpu(rapl_pmu, cpu) = NULL;
 	per_cpu(rapl_pmu_to_free, cpu) = pmu;
 	return 0;
 }
 static int rapl_cpu_notifier(struct notifier_block *self,
 			     unsigned long action, void *hcpu)
 {
 	unsigned int cpu = (long)hcpu;
 	switch (action & ~CPU_TASKS_FROZEN) {
 	case CPU_UP_PREPARE:
 		rapl_cpu_prepare(cpu);
 		break;
 	case CPU_STARTING:
 		rapl_cpu_init(cpu);
 		break;
 	case CPU_UP_CANCELED:
 	case CPU_DYING:
 		rapl_cpu_dying(cpu);
 		break;
 	case CPU_ONLINE:
 	case CPU_DEAD:
 		rapl_cpu_kfree(cpu);
 		break;
 	case CPU_DOWN_PREPARE:
 		rapl_cpu_exit(cpu);
 		break;
 	default:
 		break;
 	}
 	return NOTIFY_OK;
 }
 static const struct x86_cpu_id rapl_cpu_match[] = {
 	[0] = { .vendor = X86_VENDOR_INTEL, .family = 6 },
 	[1] = {},
 };
 static int __init rapl_pmu_init(void)
 {
 	struct rapl_pmu *pmu;
 	int cpu, ret;
 	/*
 	 * check for Intel processor family 6
 	 */
 	if (!x86_match_cpu(rapl_cpu_match))
 		return 0;
 	/* check supported CPU */
 	switch (boot_cpu_data.x86_model) {
 	case 42: /* Sandy Bridge */
 	case 58: /* Ivy Bridge */
 		rapl_cntr_mask = RAPL_IDX_CLN;
 		rapl_pmu_events_group.attrs = rapl_events_cln_attr;
 		break;
 	case 60: /* Haswell */
 	case 69: /* Haswell-Celeron */
 		rapl_cntr_mask = RAPL_IDX_HSW;
 		rapl_pmu_events_group.attrs = rapl_events_hsw_attr;
 		break;
 	case 45: /* Sandy Bridge-EP */
 	case 62: /* IvyTown */
 		rapl_cntr_mask = RAPL_IDX_SRV;
 		rapl_pmu_events_group.attrs = rapl_events_srv_attr;
 		break;
 	default:
 		/* unsupported */
 		return 0;
 	}
 	cpu_notifier_register_begin();
 	for_each_online_cpu(cpu) {
 		ret = rapl_cpu_prepare(cpu);
 		if (ret)
 			goto out;
 		rapl_cpu_init(cpu);
 	}
 	__perf_cpu_notifier(rapl_cpu_notifier);
 	ret = perf_pmu_register(&rapl_pmu_class, "power", -1);
 	if (WARN_ON(ret)) {
 		pr_info("RAPL PMU detected, registration failed (%d), RAPL PMU disabled\n", ret);
 		cpu_notifier_register_done();
 		return -1;
 	}
 	pmu = __this_cpu_read(rapl_pmu);
 	pr_info("RAPL PMU detected, hw unit 2^-%d Joules,"
 		" API unit is 2^-32 Joules,"
 		" %d fixed counters"
 		" %llu ms ovfl timer\n",
 		pmu->hw_unit,
 		hweight32(rapl_cntr_mask),
 		ktime_to_ms(pmu->timer_interval));
 out:
 	cpu_notifier_register_done();
 	return 0;
 }

tools/include/asm-generic/bitops.h

Diff comments View file @ 59b2858

 #ifndef __TOOLS_ASM_GENERIC_BITOPS_H
 #define __TOOLS_ASM_GENERIC_BITOPS_H
 /*
  * tools/ copied this from include/asm-generic/bitops.h, bit by bit as it needed
  * some functions.
  *
  * For the benefit of those who are trying to port Linux to another
  * architecture, here are some C-language equivalents.  You should
  * recode these in the native assembly language, if at all possible.
  *
  * C language equivalents written by Theodore Ts'o, 9/26/92
  */
 #include <asm-generic/bitops/__ffs.h>
 #include <asm-generic/bitops/fls.h>
 #include <asm-generic/bitops/__fls.h>
 #include <asm-generic/bitops/fls64.h>
 #include <asm-generic/bitops/find.h>
 #ifndef _TOOLS_LINUX_BITOPS_H_
 #error only <linux/bitops.h> can be included directly
 #endif
+#include <asm-generic/bitops/hweight.h>
 #include <asm-generic/bitops/atomic.h>
 #endif /* __TOOLS_ASM_GENERIC_BITOPS_H */

tools/include/asm-generic/bitops/arch_hweight.h

Diff comments View file @ 59b2858

	File was created	1	#include "../../../../include/asm-generic/bitops/arch_hweight.h"
		2

tools/include/asm-generic/bitops/const_hweight.h

Diff comments View file @ 59b2858

	File was created	1	#include "../../../../include/asm-generic/bitops/const_hweight.h"
		2

tools/include/asm-generic/bitops/hweight.h

Diff comments View file @ 59b2858

File was created	1	#ifndef _TOOLS_LINUX_ASM_GENERIC_BITOPS_HWEIGHT_H_
	2	#define _TOOLS_LINUX_ASM_GENERIC_BITOPS_HWEIGHT_H_
	3
	4	#include <asm-generic/bitops/arch_hweight.h>
	5	#include <asm-generic/bitops/const_hweight.h>
	6
	7	#endif /* _TOOLS_LINUX_ASM_GENERIC_BITOPS_HWEIGHT_H_ */
	8

tools/include/linux/bitops.h

Diff comments View file @ 59b2858

 #ifndef _TOOLS_LINUX_BITOPS_H_
 #define _TOOLS_LINUX_BITOPS_H_
+#include <asm/types.h>
 #include <linux/kernel.h>
 #include <linux/compiler.h>
-#include <asm/hweight.h>
 #ifndef __WORDSIZE
 #define __WORDSIZE (__SIZEOF_LONG__ * 8)
 #endif
 #define BITS_PER_LONG __WORDSIZE
 #define BIT_MASK(nr)		(1UL << ((nr) % BITS_PER_LONG))
 #define BIT_WORD(nr)		((nr) / BITS_PER_LONG)
 #define BITS_PER_BYTE		8
 #define BITS_TO_LONGS(nr)	DIV_ROUND_UP(nr, BITS_PER_BYTE * sizeof(long))
 #define BITS_TO_U64(nr)		DIV_ROUND_UP(nr, BITS_PER_BYTE * sizeof(u64))
 #define BITS_TO_U32(nr)		DIV_ROUND_UP(nr, BITS_PER_BYTE * sizeof(u32))
 #define BITS_TO_BYTES(nr)	DIV_ROUND_UP(nr, BITS_PER_BYTE)
+extern unsigned int __sw_hweight8(unsigned int w);
+extern unsigned int __sw_hweight16(unsigned int w);
+extern unsigned int __sw_hweight32(unsigned int w);
+extern unsigned long __sw_hweight64(__u64 w);
 /*
  * Include this here because some architectures need generic_ffs/fls in
  * scope
  *
  * XXX: this needs to be asm/bitops.h, when we get to per arch optimizations
  */
 #include <asm-generic/bitops.h>
 #define for_each_set_bit(bit, addr, size) \
 	for ((bit) = find_first_bit((addr), (size));		\
 	     (bit) < (size);					\
 	     (bit) = find_next_bit((addr), (size), (bit) + 1))
 /* same as for_each_set_bit() but use bit as value to start with */
 #define for_each_set_bit_from(bit, addr, size) \
 	for ((bit) = find_next_bit((addr), (size), (bit));	\
 	     (bit) < (size);					\
 	     (bit) = find_next_bit((addr), (size), (bit) + 1))
 static inline unsigned long hweight_long(unsigned long w)
 {
 	return sizeof(w) == 4 ? hweight32(w) : hweight64(w);
 }
 static inline unsigned fls_long(unsigned long l)
 {
 	if (sizeof(l) == 4)
 		return fls(l);
 	return fls64(l);
 }
 #endif

tools/lib/api/fs/debugfs.c

Diff comments View file @ 59b2858

1	#include <errno.h>	1	#include <errno.h>
2	#include <stdio.h>	2	#include <stdio.h>
3	#include <stdlib.h>	3	#include <stdlib.h>
4	#include <string.h>	4	#include <string.h>
5	#include <stdbool.h>	5	#include <stdbool.h>
6	#include <sys/vfs.h>	6	#include <sys/vfs.h>
7	#include <sys/mount.h>	7	#include <sys/mount.h>
8	#include <linux/kernel.h>	8	#include <linux/kernel.h>
9		9
10	#include "debugfs.h"	10	#include "debugfs.h"
11		11
12	char debugfs_mountpoint[PATH_MAX + 1] = "/sys/kernel/debug";	12	char debugfs_mountpoint[PATH_MAX + 1] = "/sys/kernel/debug";
13		13
14	static const char * const debugfs_known_mountpoints[] = {	14	static const char * const debugfs_known_mountpoints[] = {
15	"/sys/kernel/debug",	15	"/sys/kernel/debug",
16	"/debug",	16	"/debug",
17	0,	17	0,
18	};	18	};
19		19
20	static bool debugfs_found;	20	static bool debugfs_found;
21		21
22	/* find the path to the mounted debugfs */	22	/* find the path to the mounted debugfs */
23	const char *debugfs_find_mountpoint(void)	23	const char *debugfs_find_mountpoint(void)
24	{	24	{
25	const char * const *ptr;	25	const char * const *ptr;
26	char type[100];	26	char type[100];
27	FILE *fp;	27	FILE *fp;
28		28
29	if (debugfs_found)	29	if (debugfs_found)
30	return (const char *)debugfs_mountpoint;	30	return (const char *)debugfs_mountpoint;
31		31
32	ptr = debugfs_known_mountpoints;	32	ptr = debugfs_known_mountpoints;
33	while (*ptr) {	33	while (*ptr) {
34	if (debugfs_valid_mountpoint(*ptr) == 0) {	34	if (debugfs_valid_mountpoint(*ptr) == 0) {
35	debugfs_found = true;	35	debugfs_found = true;
36	strcpy(debugfs_mountpoint, *ptr);	36	strcpy(debugfs_mountpoint, *ptr);
37	return debugfs_mountpoint;	37	return debugfs_mountpoint;
38	}	38	}
39	ptr++;	39	ptr++;
40	}	40	}
41		41
42	/* give up and parse /proc/mounts */	42	/* give up and parse /proc/mounts */
43	fp = fopen("/proc/mounts", "r");	43	fp = fopen("/proc/mounts", "r");
44	if (fp == NULL)	44	if (fp == NULL)
45	return NULL;	45	return NULL;
46		46
47	while (fscanf(fp, "%s %" STR(PATH_MAX) "s %99s %s %d %d\n",	47	while (fscanf(fp, "%s %" STR(PATH_MAX) "s %99s %s %d %d\n",
48	debugfs_mountpoint, type) == 2) {	48	debugfs_mountpoint, type) == 2) {
49	if (strcmp(type, "debugfs") == 0)	49	if (strcmp(type, "debugfs") == 0)
50	break;	50	break;
51	}	51	}
52	fclose(fp);	52	fclose(fp);
53		53
54	if (strcmp(type, "debugfs") != 0)	54	if (strcmp(type, "debugfs") != 0)
55	return NULL;	55	return NULL;
56		56
57	debugfs_found = true;	57	debugfs_found = true;
58		58
59	return debugfs_mountpoint;	59	return debugfs_mountpoint;
60	}	60	}
61		61
62	/* verify that a mountpoint is actually a debugfs instance */	62	/* verify that a mountpoint is actually a debugfs instance */
63		63
64	int debugfs_valid_mountpoint(const char *debugfs)	64	int debugfs_valid_mountpoint(const char *debugfs)
65	{	65	{
66	struct statfs st_fs;	66	struct statfs st_fs;
67		67
68	if (statfs(debugfs, &st_fs) < 0)	68	if (statfs(debugfs, &st_fs) < 0)
69	return -ENOENT;	69	return -ENOENT;
70	else if (st_fs.f_type != (long) DEBUGFS_MAGIC)	70	else if ((long)st_fs.f_type != (long)DEBUGFS_MAGIC)
71	return -ENOENT;	71	return -ENOENT;
72		72
73	return 0;	73	return 0;
74	}	74	}
75		75
76	/* mount the debugfs somewhere if it's not mounted */	76	/* mount the debugfs somewhere if it's not mounted */
77	char debugfs_mount(const char mountpoint)	77	char debugfs_mount(const char mountpoint)
78	{	78	{
79	/* see if it's already mounted */	79	/* see if it's already mounted */
80	if (debugfs_find_mountpoint())	80	if (debugfs_find_mountpoint())
81	goto out;	81	goto out;
82		82
83	/* if not mounted and no argument */	83	/* if not mounted and no argument */
84	if (mountpoint == NULL) {	84	if (mountpoint == NULL) {
85	/* see if environment variable set */	85	/* see if environment variable set */
86	mountpoint = getenv(PERF_DEBUGFS_ENVIRONMENT);	86	mountpoint = getenv(PERF_DEBUGFS_ENVIRONMENT);
87	/* if no environment variable, use default */	87	/* if no environment variable, use default */
88	if (mountpoint == NULL)	88	if (mountpoint == NULL)
89	mountpoint = "/sys/kernel/debug";	89	mountpoint = "/sys/kernel/debug";
90	}	90	}
91		91
92	if (mount(NULL, mountpoint, "debugfs", 0, NULL) < 0)	92	if (mount(NULL, mountpoint, "debugfs", 0, NULL) < 0)
93	return NULL;	93	return NULL;
94		94
95	/* save the mountpoint */	95	/* save the mountpoint */
96	debugfs_found = true;	96	debugfs_found = true;
97	strncpy(debugfs_mountpoint, mountpoint, sizeof(debugfs_mountpoint));	97	strncpy(debugfs_mountpoint, mountpoint, sizeof(debugfs_mountpoint));
98	out:	98	out:
99	return debugfs_mountpoint;	99	return debugfs_mountpoint;
100	}	100	}
101		101

tools/lib/api/fs/fs.c

Diff comments View file @ 59b2858

1	/* TODO merge/factor in debugfs.c here */	1	/* TODO merge/factor in debugfs.c here */
2		2
3	#include <ctype.h>	3	#include <ctype.h>
4	#include <errno.h>	4	#include <errno.h>
5	#include <stdbool.h>	5	#include <stdbool.h>
6	#include <stdio.h>	6	#include <stdio.h>
7	#include <stdlib.h>	7	#include <stdlib.h>
8	#include <string.h>	8	#include <string.h>
9	#include <sys/vfs.h>	9	#include <sys/vfs.h>
10	#include <sys/types.h>	10	#include <sys/types.h>
11	#include <sys/stat.h>	11	#include <sys/stat.h>
12	#include <fcntl.h>	12	#include <fcntl.h>
13	#include <unistd.h>	13	#include <unistd.h>
14		14
15	#include "debugfs.h"	15	#include "debugfs.h"
16	#include "fs.h"	16	#include "fs.h"
17		17
18	static const char * const sysfs__fs_known_mountpoints[] = {	18	static const char * const sysfs__fs_known_mountpoints[] = {
19	"/sys",	19	"/sys",
20	0,	20	0,
21	};	21	};
22		22
23	static const char * const procfs__known_mountpoints[] = {	23	static const char * const procfs__known_mountpoints[] = {
24	"/proc",	24	"/proc",
25	0,	25	0,
26	};	26	};
27		27
28	struct fs {	28	struct fs {
29	const char *name;	29	const char *name;
30	const char * const *mounts;	30	const char * const *mounts;
31	char path[PATH_MAX + 1];	31	char path[PATH_MAX + 1];
32	bool found;	32	bool found;
33	long magic;	33	long magic;
34	};	34	};
35		35
36	enum {	36	enum {
37	FS__SYSFS = 0,	37	FS__SYSFS = 0,
38	FS__PROCFS = 1,	38	FS__PROCFS = 1,
39	};	39	};
40		40
41	static struct fs fs__entries[] = {	41	static struct fs fs__entries[] = {
42	[FS__SYSFS] = {	42	[FS__SYSFS] = {
43	.name = "sysfs",	43	.name = "sysfs",
44	.mounts = sysfs__fs_known_mountpoints,	44	.mounts = sysfs__fs_known_mountpoints,
45	.magic = SYSFS_MAGIC,	45	.magic = SYSFS_MAGIC,
46	},	46	},
47	[FS__PROCFS] = {	47	[FS__PROCFS] = {
48	.name = "proc",	48	.name = "proc",
49	.mounts = procfs__known_mountpoints,	49	.mounts = procfs__known_mountpoints,
50	.magic = PROC_SUPER_MAGIC,	50	.magic = PROC_SUPER_MAGIC,
51	},	51	},
52	};	52	};
53		53
54	static bool fs__read_mounts(struct fs *fs)	54	static bool fs__read_mounts(struct fs *fs)
55	{	55	{
56	bool found = false;	56	bool found = false;
57	char type[100];	57	char type[100];
58	FILE *fp;	58	FILE *fp;
59		59
60	fp = fopen("/proc/mounts", "r");	60	fp = fopen("/proc/mounts", "r");
61	if (fp == NULL)	61	if (fp == NULL)
62	return NULL;	62	return NULL;
63		63
64	while (!found &&	64	while (!found &&
65	fscanf(fp, "%s %" STR(PATH_MAX) "s %99s %s %d %d\n",	65	fscanf(fp, "%s %" STR(PATH_MAX) "s %99s %s %d %d\n",
66	fs->path, type) == 2) {	66	fs->path, type) == 2) {
67		67
68	if (strcmp(type, fs->name) == 0)	68	if (strcmp(type, fs->name) == 0)
69	found = true;	69	found = true;
70	}	70	}
71		71
72	fclose(fp);	72	fclose(fp);
73	return fs->found = found;	73	return fs->found = found;
74	}	74	}
75		75
76	static int fs__valid_mount(const char *fs, long magic)	76	static int fs__valid_mount(const char *fs, long magic)
77	{	77	{
78	struct statfs st_fs;	78	struct statfs st_fs;
79		79
80	if (statfs(fs, &st_fs) < 0)	80	if (statfs(fs, &st_fs) < 0)
81	return -ENOENT;	81	return -ENOENT;
82	else if (st_fs.f_type != magic)	82	else if ((long)st_fs.f_type != magic)
83	return -ENOENT;	83	return -ENOENT;
84		84
85	return 0;	85	return 0;
86	}	86	}
87		87
88	static bool fs__check_mounts(struct fs *fs)	88	static bool fs__check_mounts(struct fs *fs)
89	{	89	{
90	const char * const *ptr;	90	const char * const *ptr;
91		91
92	ptr = fs->mounts;	92	ptr = fs->mounts;
93	while (*ptr) {	93	while (*ptr) {
94	if (fs__valid_mount(*ptr, fs->magic) == 0) {	94	if (fs__valid_mount(*ptr, fs->magic) == 0) {
95	fs->found = true;	95	fs->found = true;
96	strcpy(fs->path, *ptr);	96	strcpy(fs->path, *ptr);
97	return true;	97	return true;
98	}	98	}
99	ptr++;	99	ptr++;
100	}	100	}
101		101
102	return false;	102	return false;
103	}	103	}
104		104
105	static void mem_toupper(char *f, size_t len)	105	static void mem_toupper(char *f, size_t len)
106	{	106	{
107	while (len) {	107	while (len) {
108	f = toupper(f);	108	f = toupper(f);
109	f++;	109	f++;
110	len--;	110	len--;
111	}	111	}
112	}	112	}
113		113
114	/*	114	/*
115	* Check for "NAME_PATH" environment variable to override fs location (for	115	* Check for "NAME_PATH" environment variable to override fs location (for
116	* testing). This matches the recommendation in Documentation/sysfs-rules.txt	116	* testing). This matches the recommendation in Documentation/sysfs-rules.txt
117	* for SYSFS_PATH.	117	* for SYSFS_PATH.
118	*/	118	*/
119	static bool fs__env_override(struct fs *fs)	119	static bool fs__env_override(struct fs *fs)
120	{	120	{
121	char *override_path;	121	char *override_path;
122	size_t name_len = strlen(fs->name);	122	size_t name_len = strlen(fs->name);
123	/* name + "_PATH" + '\0' */	123	/* name + "_PATH" + '\0' */
124	char upper_name[name_len + 5 + 1];	124	char upper_name[name_len + 5 + 1];
125	memcpy(upper_name, fs->name, name_len);	125	memcpy(upper_name, fs->name, name_len);
126	mem_toupper(upper_name, name_len);	126	mem_toupper(upper_name, name_len);
127	strcpy(&upper_name[name_len], "_PATH");	127	strcpy(&upper_name[name_len], "_PATH");
128		128
129	override_path = getenv(upper_name);	129	override_path = getenv(upper_name);
130	if (!override_path)	130	if (!override_path)
131	return false;	131	return false;
132		132
133	fs->found = true;	133	fs->found = true;
134	strncpy(fs->path, override_path, sizeof(fs->path));	134	strncpy(fs->path, override_path, sizeof(fs->path));
135	return true;	135	return true;
136	}	136	}
137		137
138	static const char fs__get_mountpoint(struct fs fs)	138	static const char fs__get_mountpoint(struct fs fs)
139	{	139	{
140	if (fs__env_override(fs))	140	if (fs__env_override(fs))
141	return fs->path;	141	return fs->path;
142		142
143	if (fs__check_mounts(fs))	143	if (fs__check_mounts(fs))
144	return fs->path;	144	return fs->path;
145		145
146	if (fs__read_mounts(fs))	146	if (fs__read_mounts(fs))
147	return fs->path;	147	return fs->path;
148		148
149	return NULL;	149	return NULL;
150	}	150	}
151		151
152	static const char *fs__mountpoint(int idx)	152	static const char *fs__mountpoint(int idx)
153	{	153	{
154	struct fs *fs = &fs__entries[idx];	154	struct fs *fs = &fs__entries[idx];
155		155
156	if (fs->found)	156	if (fs->found)
157	return (const char *)fs->path;	157	return (const char *)fs->path;
158		158
159	return fs__get_mountpoint(fs);	159	return fs__get_mountpoint(fs);
160	}	160	}
161		161
162	#define FS__MOUNTPOINT(name, idx) \	162	#define FS__MOUNTPOINT(name, idx) \
163	const char *name##__mountpoint(void) \	163	const char *name##__mountpoint(void) \
164	{ \	164	{ \
165	return fs__mountpoint(idx); \	165	return fs__mountpoint(idx); \
166	}	166	}
167		167
168	FS__MOUNTPOINT(sysfs, FS__SYSFS);	168	FS__MOUNTPOINT(sysfs, FS__SYSFS);
169	FS__MOUNTPOINT(procfs, FS__PROCFS);	169	FS__MOUNTPOINT(procfs, FS__PROCFS);
170		170
171	int filename__read_int(const char filename, int value)	171	int filename__read_int(const char filename, int value)
172	{	172	{
173	char line[64];	173	char line[64];
174	int fd = open(filename, O_RDONLY), err = -1;	174	int fd = open(filename, O_RDONLY), err = -1;
175		175
176	if (fd < 0)	176	if (fd < 0)
177	return -1;	177	return -1;
178		178
179	if (read(fd, line, sizeof(line)) > 0) {	179	if (read(fd, line, sizeof(line)) > 0) {
180	*value = atoi(line);	180	*value = atoi(line);
181	err = 0;	181	err = 0;
182	}	182	}
183		183
184	close(fd);	184	close(fd);
185	return err;	185	return err;
186	}	186	}
187		187
188	int sysctl__read_int(const char sysctl, int value)	188	int sysctl__read_int(const char sysctl, int value)
189	{	189	{
190	char path[PATH_MAX];	190	char path[PATH_MAX];
191	const char *procfs = procfs__mountpoint();	191	const char *procfs = procfs__mountpoint();
192		192
193	if (!procfs)	193	if (!procfs)
194	return -1;	194	return -1;
195		195
196	snprintf(path, sizeof(path), "%s/sys/%s", procfs, sysctl);	196	snprintf(path, sizeof(path), "%s/sys/%s", procfs, sysctl);
197		197
198	return filename__read_int(path, value);	198	return filename__read_int(path, value);
199	}	199	}
200		200

tools/perf/MANIFEST

Diff comments View file @ 59b2858

1	tools/perf	1	tools/perf
2	tools/scripts	2	tools/scripts
3	tools/lib/traceevent	3	tools/lib/traceevent
4	tools/lib/api	4	tools/lib/api
5	tools/lib/symbol/kallsyms.c	5	tools/lib/symbol/kallsyms.c
6	tools/lib/symbol/kallsyms.h	6	tools/lib/symbol/kallsyms.h
7	tools/lib/util/find_next_bit.c	7	tools/lib/util/find_next_bit.c
8	tools/include/asm/bug.h	8	tools/include/asm/bug.h
		9	tools/include/asm-generic/bitops/arch_hweight.h
9	tools/include/asm-generic/bitops/atomic.h	10	tools/include/asm-generic/bitops/atomic.h
		11	tools/include/asm-generic/bitops/const_hweight.h
10	tools/include/asm-generic/bitops/__ffs.h	12	tools/include/asm-generic/bitops/__ffs.h
11	tools/include/asm-generic/bitops/__fls.h	13	tools/include/asm-generic/bitops/__fls.h
12	tools/include/asm-generic/bitops/find.h	14	tools/include/asm-generic/bitops/find.h
13	tools/include/asm-generic/bitops/fls64.h	15	tools/include/asm-generic/bitops/fls64.h
14	tools/include/asm-generic/bitops/fls.h	16	tools/include/asm-generic/bitops/fls.h
		17	tools/include/asm-generic/bitops/hweight.h
15	tools/include/asm-generic/bitops.h	18	tools/include/asm-generic/bitops.h
16	tools/include/linux/bitops.h	19	tools/include/linux/bitops.h
17	tools/include/linux/compiler.h	20	tools/include/linux/compiler.h
18	tools/include/linux/export.h	21	tools/include/linux/export.h
19	tools/include/linux/hash.h	22	tools/include/linux/hash.h
20	tools/include/linux/log2.h	23	tools/include/linux/log2.h
21	tools/include/linux/types.h	24	tools/include/linux/types.h
		25	include/asm-generic/bitops/arch_hweight.h
		26	include/asm-generic/bitops/const_hweight.h
22	include/asm-generic/bitops/fls64.h	27	include/asm-generic/bitops/fls64.h
23	include/asm-generic/bitops/__fls.h	28	include/asm-generic/bitops/__fls.h
24	include/asm-generic/bitops/fls.h	29	include/asm-generic/bitops/fls.h
25	include/linux/const.h	30	include/linux/const.h
26	include/linux/perf_event.h	31	include/linux/perf_event.h
27	include/linux/rbtree.h	32	include/linux/rbtree.h
28	include/linux/list.h	33	include/linux/list.h
29	include/linux/hash.h	34	include/linux/hash.h
30	include/linux/stringify.h	35	include/linux/stringify.h
31	lib/find_next_bit.c	36	lib/find_next_bit.c
		37	lib/hweight.c
32	lib/rbtree.c	38	lib/rbtree.c
33	include/linux/swab.h	39	include/linux/swab.h
34	arch//include/asm/unistd.h	40	arch//include/asm/unistd.h
35	arch/*/include/asm/perf_regs.h	41	arch/*/include/asm/perf_regs.h
36	arch//include/uapi/asm/unistd.h	42	arch//include/uapi/asm/unistd.h
37	arch/*/include/uapi/asm/perf_regs.h	43	arch/*/include/uapi/asm/perf_regs.h
38	arch//lib/memcpy.S	44	arch//lib/memcpy.S
39	arch//lib/memset.S	45	arch//lib/memset.S
40	include/linux/poison.h	46	include/linux/poison.h
41	include/linux/magic.h	47	include/linux/magic.h
42	include/linux/hw_breakpoint.h	48	include/linux/hw_breakpoint.h
43	include/linux/rbtree_augmented.h	49	include/linux/rbtree_augmented.h
44	include/uapi/linux/perf_event.h	50	include/uapi/linux/perf_event.h
45	include/uapi/linux/const.h	51	include/uapi/linux/const.h
46	include/uapi/linux/swab.h	52	include/uapi/linux/swab.h
47	include/uapi/linux/hw_breakpoint.h	53	include/uapi/linux/hw_breakpoint.h
48	arch/x86/include/asm/svm.h	54	arch/x86/include/asm/svm.h
49	arch/x86/include/asm/vmx.h	55	arch/x86/include/asm/vmx.h
50	arch/x86/include/asm/kvm_host.h	56	arch/x86/include/asm/kvm_host.h
51	arch/x86/include/uapi/asm/svm.h	57	arch/x86/include/uapi/asm/svm.h
52	arch/x86/include/uapi/asm/vmx.h	58	arch/x86/include/uapi/asm/vmx.h
53	arch/x86/include/uapi/asm/kvm.h	59	arch/x86/include/uapi/asm/kvm.h
54	arch/x86/include/uapi/asm/kvm_perf.h	60	arch/x86/include/uapi/asm/kvm_perf.h
55	arch/s390/include/uapi/asm/sie.h	61	arch/s390/include/uapi/asm/sie.h
56	arch/s390/include/uapi/asm/kvm_perf.h	62	arch/s390/include/uapi/asm/kvm_perf.h
57		63

tools/perf/Makefile.perf

Diff comments View file @ 59b2858

 include ../scripts/Makefile.include
 # The default target of this Makefile is...
 all:
 include config/utilities.mak
 # Define V to have a more verbose compile.
 #
 # Define VF to have a more verbose feature check output.
 #
 # Define O to save output files in a separate directory.
 #
 # Define ARCH as name of target architecture if you want cross-builds.
 #
 # Define CROSS_COMPILE as prefix name of compiler if you want cross-builds.
 #
 # Define NO_LIBPERL to disable perl script extension.
 #
 # Define NO_LIBPYTHON to disable python script extension.
 #
 # Define PYTHON to point to the python binary if the default
 # `python' is not correct; for example: PYTHON=python2
 #
 # Define PYTHON_CONFIG to point to the python-config binary if
 # the default `$(PYTHON)-config' is not correct.
 #
 # Define ASCIIDOC8 if you want to format documentation with AsciiDoc 8
 #
 # Define DOCBOOK_XSL_172 if you want to format man pages with DocBook XSL v1.72.
 #
 # Define LDFLAGS=-static to build a static binary.
 #
 # Define EXTRA_CFLAGS=-m64 or EXTRA_CFLAGS=-m32 as appropriate for cross-builds.
 #
 # Define NO_DWARF if you do not want debug-info analysis feature at all.
 #
 # Define WERROR=0 to disable treating any warnings as errors.
 #
 # Define NO_NEWT if you do not want TUI support. (deprecated)
 #
 # Define NO_SLANG if you do not want TUI support.
 #
 # Define NO_GTK2 if you do not want GTK+ GUI support.
 #
 # Define NO_DEMANGLE if you do not want C++ symbol demangling.
 #
 # Define NO_LIBELF if you do not want libelf dependency (e.g. cross-builds)
 #
 # Define NO_LIBUNWIND if you do not want libunwind dependency for dwarf
 # backtrace post unwind.
 #
 # Define NO_BACKTRACE if you do not want stack backtrace debug feature
 #
 # Define NO_LIBNUMA if you do not want numa perf benchmark
 #
 # Define NO_LIBAUDIT if you do not want libaudit support
 #
 # Define NO_LIBBIONIC if you do not want bionic support
 #
 # Define NO_LIBDW_DWARF_UNWIND if you do not want libdw support
 # for dwarf backtrace post unwind.
 #
 # Define NO_PERF_READ_VDSO32 if you do not want to build perf-read-vdso32
 # for reading the 32-bit compatibility VDSO in 64-bit mode
 #
 # Define NO_PERF_READ_VDSOX32 if you do not want to build perf-read-vdsox32
 # for reading the x32 mode 32-bit compatibility VDSO in 64-bit mode
 #
 # Define NO_ZLIB if you do not want to support compressed kernel modules
 ifeq ($(srctree),)
 srctree := $(patsubst %/,%,$(dir $(shell pwd)))
 srctree := $(patsubst %/,%,$(dir $(srctree)))
 #$(info Determined 'srctree' to be $(srctree))
 endif
 ifneq ($(objtree),)
 #$(info Determined 'objtree' to be $(objtree))
 endif
 ifneq ($(OUTPUT),)
 #$(info Determined 'OUTPUT' to be $(OUTPUT))
 endif
 $(OUTPUT)PERF-VERSION-FILE: ../../.git/HEAD
 	@$(SHELL_PATH) util/PERF-VERSION-GEN $(OUTPUT)
 	@touch $(OUTPUT)PERF-VERSION-FILE
 CC = $(CROSS_COMPILE)gcc
 AR = $(CROSS_COMPILE)ar
 PKG_CONFIG = $(CROSS_COMPILE)pkg-config
 RM      = rm -f
 LN      = ln -f
 MKDIR   = mkdir
 FIND    = find
 INSTALL = install
 FLEX    = flex
 BISON   = bison
 STRIP   = strip
 LIB_DIR          = $(srctree)/tools/lib/api/
 TRACE_EVENT_DIR = $(srctree)/tools/lib/traceevent/
 # include config/Makefile by default and rule out
 # non-config cases
 config := 1
 NON_CONFIG_TARGETS := clean TAGS tags cscope help
 ifdef MAKECMDGOALS
 ifeq ($(filter-out $(NON_CONFIG_TARGETS),$(MAKECMDGOALS)),)
   config := 0
 endif
 endif
 ifeq ($(config),1)
 include config/Makefile
 endif
 export prefix bindir sharedir sysconfdir DESTDIR
 # sparse is architecture-neutral, which means that we need to tell it
 # explicitly what architecture to check for. Fix this up for yours..
 SPARSE_FLAGS = -D__BIG_ENDIAN__ -D__powerpc__
 # Guard against environment variables
 BUILTIN_OBJS =
 LIB_H =
 LIB_OBJS =
 GTK_OBJS =
 PYRF_OBJS =
 SCRIPT_SH =
 SCRIPT_SH += perf-archive.sh
 SCRIPT_SH += perf-with-kcore.sh
 grep-libs = $(filter -l%,$(1))
 strip-libs = $(filter-out -l%,$(1))
 ifneq ($(OUTPUT),)
   TE_PATH=$(OUTPUT)
 ifneq ($(subdir),)
   LIB_PATH=$(OUTPUT)/../lib/api/
 else
   LIB_PATH=$(OUTPUT)
 endif
 else
   TE_PATH=$(TRACE_EVENT_DIR)
   LIB_PATH=$(LIB_DIR)
 endif
 LIBTRACEEVENT = $(TE_PATH)libtraceevent.a
 export LIBTRACEEVENT
 LIBAPIKFS = $(LIB_PATH)libapikfs.a
 export LIBAPIKFS
 # python extension build directories
 PYTHON_EXTBUILD     := $(OUTPUT)python_ext_build/
 PYTHON_EXTBUILD_LIB := $(PYTHON_EXTBUILD)lib/
 PYTHON_EXTBUILD_TMP := $(PYTHON_EXTBUILD)tmp/
 export PYTHON_EXTBUILD_LIB PYTHON_EXTBUILD_TMP
 python-clean := $(call QUIET_CLEAN, python) $(RM) -r $(PYTHON_EXTBUILD) $(OUTPUT)python/perf.so
 PYTHON_EXT_SRCS := $(shell grep -v ^\# util/python-ext-sources)
 PYTHON_EXT_DEPS := util/python-ext-sources util/setup.py $(LIBTRACEEVENT) $(LIBAPIKFS)
 $(OUTPUT)python/perf.so: $(PYTHON_EXT_SRCS) $(PYTHON_EXT_DEPS)
 	$(QUIET_GEN)CFLAGS='$(CFLAGS)' $(PYTHON_WORD) util/setup.py \
 	  --quiet build_ext; \
 	mkdir -p $(OUTPUT)python && \
 	cp $(PYTHON_EXTBUILD_LIB)perf.so $(OUTPUT)python/
 #
 # No Perl scripts right now:
 #
 SCRIPTS = $(patsubst %.sh,%,$(SCRIPT_SH))
 PROGRAMS += $(OUTPUT)perf
 ifndef NO_PERF_READ_VDSO32
 PROGRAMS += $(OUTPUT)perf-read-vdso32
 endif
 ifndef NO_PERF_READ_VDSOX32
 PROGRAMS += $(OUTPUT)perf-read-vdsox32
 endif
 # what 'all' will build and 'install' will install, in perfexecdir
 ALL_PROGRAMS = $(PROGRAMS) $(SCRIPTS)
 # what 'all' will build but not install in perfexecdir
 OTHER_PROGRAMS = $(OUTPUT)perf
 # Set paths to tools early so that they can be used for version tests.
 ifndef SHELL_PATH
   SHELL_PATH = /bin/sh
 endif
 ifndef PERL_PATH
   PERL_PATH = /usr/bin/perl
 endif
 export PERL_PATH
 $(OUTPUT)util/parse-events-flex.c: util/parse-events.l $(OUTPUT)util/parse-events-bison.c
 	$(QUIET_FLEX)$(FLEX) -o $@ --header-file=$(OUTPUT)util/parse-events-flex.h $(PARSER_DEBUG_FLEX) util/parse-events.l
 $(OUTPUT)util/parse-events-bison.c: util/parse-events.y
 	$(QUIET_BISON)$(BISON) -v util/parse-events.y -d $(PARSER_DEBUG_BISON) -o $(OUTPUT)util/parse-events-bison.c -p parse_events_
 $(OUTPUT)util/pmu-flex.c: util/pmu.l $(OUTPUT)util/pmu-bison.c
 	$(QUIET_FLEX)$(FLEX) -o $@ --header-file=$(OUTPUT)util/pmu-flex.h util/pmu.l
 $(OUTPUT)util/pmu-bison.c: util/pmu.y
 	$(QUIET_BISON)$(BISON) -v util/pmu.y -d -o $(OUTPUT)util/pmu-bison.c -p perf_pmu_
 $(OUTPUT)util/parse-events.o: $(OUTPUT)util/parse-events-flex.c $(OUTPUT)util/parse-events-bison.c
 $(OUTPUT)util/pmu.o: $(OUTPUT)util/pmu-flex.c $(OUTPUT)util/pmu-bison.c
 LIB_FILE=$(OUTPUT)libperf.a
 LIB_H += ../lib/symbol/kallsyms.h
 LIB_H += ../../include/uapi/linux/perf_event.h
 LIB_H += ../../include/linux/rbtree.h
 LIB_H += ../../include/linux/list.h
 LIB_H += ../../include/uapi/linux/const.h
 LIB_H += ../include/linux/hash.h
 LIB_H += ../../include/linux/stringify.h
 LIB_H += util/include/linux/bitmap.h
 LIB_H += ../include/linux/bitops.h
+LIB_H += ../include/asm-generic/bitops/arch_hweight.h
 LIB_H += ../include/asm-generic/bitops/atomic.h
+LIB_H += ../include/asm-generic/bitops/const_hweight.h
 LIB_H += ../include/asm-generic/bitops/find.h
 LIB_H += ../include/asm-generic/bitops/fls64.h
 LIB_H += ../include/asm-generic/bitops/fls.h
 LIB_H += ../include/asm-generic/bitops/__ffs.h
 LIB_H += ../include/asm-generic/bitops/__fls.h
+LIB_H += ../include/asm-generic/bitops/hweight.h
 LIB_H += ../include/asm-generic/bitops.h
 LIB_H += ../include/linux/compiler.h
 LIB_H += ../include/linux/log2.h
 LIB_H += util/include/linux/const.h
 LIB_H += util/include/linux/ctype.h
 LIB_H += util/include/linux/kernel.h
 LIB_H += util/include/linux/list.h
 LIB_H += ../include/linux/export.h
 LIB_H += util/include/linux/poison.h
 LIB_H += util/include/linux/rbtree.h
 LIB_H += util/include/linux/rbtree_augmented.h
 LIB_H += util/include/linux/string.h
 LIB_H += ../include/linux/types.h
 LIB_H += util/include/linux/linkage.h
 LIB_H += util/include/asm/asm-offsets.h
 LIB_H += ../include/asm/bug.h
 LIB_H += util/include/asm/byteorder.h
-LIB_H += util/include/asm/hweight.h
 LIB_H += util/include/asm/swab.h
 LIB_H += util/include/asm/system.h
 LIB_H += util/include/asm/uaccess.h
 LIB_H += util/include/dwarf-regs.h
 LIB_H += util/include/asm/dwarf2.h
 LIB_H += util/include/asm/cpufeature.h
 LIB_H += util/include/asm/unistd_32.h
 LIB_H += util/include/asm/unistd_64.h
 LIB_H += perf.h
 LIB_H += util/annotate.h
 LIB_H += util/cache.h
 LIB_H += util/callchain.h
 LIB_H += util/build-id.h
 LIB_H += util/db-export.h
 LIB_H += util/debug.h
 LIB_H += util/pmu.h
 LIB_H += util/event.h
 LIB_H += util/evsel.h
 LIB_H += util/evlist.h
 LIB_H += util/exec_cmd.h
 LIB_H += util/find-vdso-map.c
 LIB_H += util/levenshtein.h
 LIB_H += util/machine.h
 LIB_H += util/map.h
 LIB_H += util/parse-options.h
 LIB_H += util/parse-events.h
 LIB_H += util/quote.h
 LIB_H += util/util.h
 LIB_H += util/xyarray.h
 LIB_H += util/header.h
 LIB_H += util/help.h
 LIB_H += util/session.h
 LIB_H += util/ordered-events.h
 LIB_H += util/strbuf.h
 LIB_H += util/strlist.h
 LIB_H += util/strfilter.h
 LIB_H += util/svghelper.h
 LIB_H += util/tool.h
 LIB_H += util/run-command.h
 LIB_H += util/sigchain.h
 LIB_H += util/dso.h
 LIB_H += util/symbol.h
 LIB_H += util/color.h
 LIB_H += util/values.h
 LIB_H += util/sort.h
 LIB_H += util/hist.h
 LIB_H += util/comm.h
 LIB_H += util/thread.h
 LIB_H += util/thread_map.h
 LIB_H += util/trace-event.h
 LIB_H += util/probe-finder.h
 LIB_H += util/dwarf-aux.h
 LIB_H += util/probe-event.h
 LIB_H += util/pstack.h
 LIB_H += util/cpumap.h
 LIB_H += util/top.h
 LIB_H += $(ARCH_INCLUDE)
 LIB_H += util/cgroup.h
 LIB_H += $(LIB_INCLUDE)traceevent/event-parse.h
 LIB_H += util/target.h
 LIB_H += util/rblist.h
 LIB_H += util/intlist.h
 LIB_H += util/perf_regs.h
 LIB_H += util/unwind.h
 LIB_H += util/vdso.h
 LIB_H += util/tsc.h
 LIB_H += ui/helpline.h
 LIB_H += ui/progress.h
 LIB_H += ui/util.h
 LIB_H += ui/ui.h
 LIB_H += util/data.h
 LIB_H += util/kvm-stat.h
 LIB_H += util/thread-stack.h
 LIB_OBJS += $(OUTPUT)util/abspath.o
 LIB_OBJS += $(OUTPUT)util/alias.o
 LIB_OBJS += $(OUTPUT)util/annotate.o
 LIB_OBJS += $(OUTPUT)util/build-id.o
 LIB_OBJS += $(OUTPUT)util/config.o
 LIB_OBJS += $(OUTPUT)util/ctype.o
 LIB_OBJS += $(OUTPUT)util/db-export.o
 LIB_OBJS += $(OUTPUT)util/pmu.o
 LIB_OBJS += $(OUTPUT)util/environment.o
 LIB_OBJS += $(OUTPUT)util/event.o
 LIB_OBJS += $(OUTPUT)util/evlist.o
 LIB_OBJS += $(OUTPUT)util/evsel.o
 LIB_OBJS += $(OUTPUT)util/exec_cmd.o
 LIB_OBJS += $(OUTPUT)util/find_next_bit.o
 LIB_OBJS += $(OUTPUT)util/help.o
 LIB_OBJS += $(OUTPUT)util/kallsyms.o
 LIB_OBJS += $(OUTPUT)util/levenshtein.o
 LIB_OBJS += $(OUTPUT)util/parse-options.o
 LIB_OBJS += $(OUTPUT)util/parse-events.o
 LIB_OBJS += $(OUTPUT)util/path.o
 LIB_OBJS += $(OUTPUT)util/rbtree.o
 LIB_OBJS += $(OUTPUT)util/bitmap.o
 LIB_OBJS += $(OUTPUT)util/hweight.o
 LIB_OBJS += $(OUTPUT)util/run-command.o
 LIB_OBJS += $(OUTPUT)util/quote.o
 LIB_OBJS += $(OUTPUT)util/strbuf.o
 LIB_OBJS += $(OUTPUT)util/string.o
 LIB_OBJS += $(OUTPUT)util/strlist.o
 LIB_OBJS += $(OUTPUT)util/strfilter.o
 LIB_OBJS += $(OUTPUT)util/top.o
 LIB_OBJS += $(OUTPUT)util/usage.o
 LIB_OBJS += $(OUTPUT)util/wrapper.o
 LIB_OBJS += $(OUTPUT)util/sigchain.o
 LIB_OBJS += $(OUTPUT)util/dso.o
 LIB_OBJS += $(OUTPUT)util/symbol.o
 LIB_OBJS += $(OUTPUT)util/symbol-elf.o
 LIB_OBJS += $(OUTPUT)util/color.o
 LIB_OBJS += $(OUTPUT)util/pager.o
 LIB_OBJS += $(OUTPUT)util/header.o
 LIB_OBJS += $(OUTPUT)util/callchain.o
 LIB_OBJS += $(OUTPUT)util/values.o
 LIB_OBJS += $(OUTPUT)util/debug.o
 LIB_OBJS += $(OUTPUT)util/machine.o
 LIB_OBJS += $(OUTPUT)util/map.o
 LIB_OBJS += $(OUTPUT)util/pstack.o
 LIB_OBJS += $(OUTPUT)util/session.o
 LIB_OBJS += $(OUTPUT)util/ordered-events.o
 LIB_OBJS += $(OUTPUT)util/comm.o
 LIB_OBJS += $(OUTPUT)util/thread.o
 LIB_OBJS += $(OUTPUT)util/thread_map.o
 LIB_OBJS += $(OUTPUT)util/trace-event-parse.o
 LIB_OBJS += $(OUTPUT)util/parse-events-flex.o
 LIB_OBJS += $(OUTPUT)util/parse-events-bison.o
 LIB_OBJS += $(OUTPUT)util/pmu-flex.o
 LIB_OBJS += $(OUTPUT)util/pmu-bison.o
 LIB_OBJS += $(OUTPUT)util/trace-event-read.o
 LIB_OBJS += $(OUTPUT)util/trace-event-info.o
 LIB_OBJS += $(OUTPUT)util/trace-event-scripting.o
 LIB_OBJS += $(OUTPUT)util/trace-event.o
 LIB_OBJS += $(OUTPUT)util/svghelper.o
 LIB_OBJS += $(OUTPUT)util/sort.o
 LIB_OBJS += $(OUTPUT)util/hist.o
 LIB_OBJS += $(OUTPUT)util/probe-event.o
 LIB_OBJS += $(OUTPUT)util/util.o
 LIB_OBJS += $(OUTPUT)util/xyarray.o
 LIB_OBJS += $(OUTPUT)util/cpumap.o
 LIB_OBJS += $(OUTPUT)util/cgroup.o
 LIB_OBJS += $(OUTPUT)util/target.o
 LIB_OBJS += $(OUTPUT)util/rblist.o
 LIB_OBJS += $(OUTPUT)util/intlist.o
 LIB_OBJS += $(OUTPUT)util/vdso.o
 LIB_OBJS += $(OUTPUT)util/stat.o
 LIB_OBJS += $(OUTPUT)util/record.o
 LIB_OBJS += $(OUTPUT)util/srcline.o
 LIB_OBJS += $(OUTPUT)util/data.o
 LIB_OBJS += $(OUTPUT)util/tsc.o
 LIB_OBJS += $(OUTPUT)util/cloexec.o
 LIB_OBJS += $(OUTPUT)util/thread-stack.o
 LIB_OBJS += $(OUTPUT)ui/setup.o
 LIB_OBJS += $(OUTPUT)ui/helpline.o
 LIB_OBJS += $(OUTPUT)ui/progress.o
 LIB_OBJS += $(OUTPUT)ui/util.o
 LIB_OBJS += $(OUTPUT)ui/hist.o
 LIB_OBJS += $(OUTPUT)ui/stdio/hist.o
 LIB_OBJS += $(OUTPUT)arch/common.o
 LIB_OBJS += $(OUTPUT)tests/parse-events.o
 LIB_OBJS += $(OUTPUT)tests/dso-data.o
 LIB_OBJS += $(OUTPUT)tests/attr.o
 LIB_OBJS += $(OUTPUT)tests/vmlinux-kallsyms.o
 LIB_OBJS += $(OUTPUT)tests/open-syscall.o
 LIB_OBJS += $(OUTPUT)tests/open-syscall-all-cpus.o
 LIB_OBJS += $(OUTPUT)tests/open-syscall-tp-fields.o
 LIB_OBJS += $(OUTPUT)tests/mmap-basic.o
 LIB_OBJS += $(OUTPUT)tests/perf-record.o
 LIB_OBJS += $(OUTPUT)tests/rdpmc.o
 LIB_OBJS += $(OUTPUT)tests/evsel-roundtrip-name.o
 LIB_OBJS += $(OUTPUT)tests/evsel-tp-sched.o
 LIB_OBJS += $(OUTPUT)tests/fdarray.o
 LIB_OBJS += $(OUTPUT)tests/pmu.o
 LIB_OBJS += $(OUTPUT)tests/hists_common.o
 LIB_OBJS += $(OUTPUT)tests/hists_link.o
 LIB_OBJS += $(OUTPUT)tests/hists_filter.o
 LIB_OBJS += $(OUTPUT)tests/hists_output.o
 LIB_OBJS += $(OUTPUT)tests/hists_cumulate.o
 LIB_OBJS += $(OUTPUT)tests/python-use.o
 LIB_OBJS += $(OUTPUT)tests/bp_signal.o
 LIB_OBJS += $(OUTPUT)tests/bp_signal_overflow.o
 LIB_OBJS += $(OUTPUT)tests/task-exit.o
 LIB_OBJS += $(OUTPUT)tests/sw-clock.o
 ifeq ($(ARCH),x86)
 LIB_OBJS += $(OUTPUT)tests/perf-time-to-tsc.o
 endif
 LIB_OBJS += $(OUTPUT)tests/code-reading.o
 LIB_OBJS += $(OUTPUT)tests/sample-parsing.o
 LIB_OBJS += $(OUTPUT)tests/parse-no-sample-id-all.o
 ifndef NO_DWARF_UNWIND
 ifeq ($(ARCH),$(filter $(ARCH),x86 arm))
 LIB_OBJS += $(OUTPUT)tests/dwarf-unwind.o
 endif
 endif
 LIB_OBJS += $(OUTPUT)tests/mmap-thread-lookup.o
 LIB_OBJS += $(OUTPUT)tests/thread-mg-share.o
 LIB_OBJS += $(OUTPUT)tests/switch-tracking.o
 BUILTIN_OBJS += $(OUTPUT)builtin-annotate.o
 BUILTIN_OBJS += $(OUTPUT)builtin-bench.o
 # Benchmark modules
 BUILTIN_OBJS += $(OUTPUT)bench/sched-messaging.o
 BUILTIN_OBJS += $(OUTPUT)bench/sched-pipe.o
-ifeq ($(RAW_ARCH),x86_64)
+ifeq ($(ARCH), x86)
+ifeq ($(IS_64_BIT), 1)
 BUILTIN_OBJS += $(OUTPUT)bench/mem-memcpy-x86-64-asm.o
 BUILTIN_OBJS += $(OUTPUT)bench/mem-memset-x86-64-asm.o
 endif
+endif
 BUILTIN_OBJS += $(OUTPUT)bench/mem-memcpy.o
 BUILTIN_OBJS += $(OUTPUT)bench/futex-hash.o
 BUILTIN_OBJS += $(OUTPUT)bench/futex-wake.o
 BUILTIN_OBJS += $(OUTPUT)bench/futex-requeue.o
 BUILTIN_OBJS += $(OUTPUT)builtin-diff.o
 BUILTIN_OBJS += $(OUTPUT)builtin-evlist.o
 BUILTIN_OBJS += $(OUTPUT)builtin-help.o
 BUILTIN_OBJS += $(OUTPUT)builtin-sched.o
 BUILTIN_OBJS += $(OUTPUT)builtin-buildid-list.o
 BUILTIN_OBJS += $(OUTPUT)builtin-buildid-cache.o
 BUILTIN_OBJS += $(OUTPUT)builtin-list.o
 BUILTIN_OBJS += $(OUTPUT)builtin-record.o
 BUILTIN_OBJS += $(OUTPUT)builtin-report.o
 BUILTIN_OBJS += $(OUTPUT)builtin-stat.o
 BUILTIN_OBJS += $(OUTPUT)builtin-timechart.o
 BUILTIN_OBJS += $(OUTPUT)builtin-top.o
 BUILTIN_OBJS += $(OUTPUT)builtin-script.o
 BUILTIN_OBJS += $(OUTPUT)builtin-probe.o
 BUILTIN_OBJS += $(OUTPUT)builtin-kmem.o
 BUILTIN_OBJS += $(OUTPUT)builtin-lock.o
 BUILTIN_OBJS += $(OUTPUT)builtin-kvm.o
 BUILTIN_OBJS += $(OUTPUT)builtin-inject.o
 BUILTIN_OBJS += $(OUTPUT)tests/builtin-test.o
 BUILTIN_OBJS += $(OUTPUT)builtin-mem.o
 PERFLIBS = $(LIB_FILE) $(LIBAPIKFS) $(LIBTRACEEVENT)
 # We choose to avoid "if .. else if .. else .. endif endif"
 # because maintaining the nesting to match is a pain.  If
 # we had "elif" things would have been much nicer...
 -include arch/$(ARCH)/Makefile
 ifneq ($(OUTPUT),)
   CFLAGS += -I$(OUTPUT)
 endif
 ifdef NO_LIBELF
 # Remove ELF/DWARF dependent codes
 LIB_OBJS := $(filter-out $(OUTPUT)util/symbol-elf.o,$(LIB_OBJS))
 LIB_OBJS := $(filter-out $(OUTPUT)util/dwarf-aux.o,$(LIB_OBJS))
 LIB_OBJS := $(filter-out $(OUTPUT)util/probe-event.o,$(LIB_OBJS))
 LIB_OBJS := $(filter-out $(OUTPUT)util/probe-finder.o,$(LIB_OBJS))
 BUILTIN_OBJS := $(filter-out $(OUTPUT)builtin-probe.o,$(BUILTIN_OBJS))
 # Use minimal symbol handling
 LIB_OBJS += $(OUTPUT)util/symbol-minimal.o
 else # NO_LIBELF
 ifndef NO_DWARF
   LIB_OBJS += $(OUTPUT)util/probe-finder.o
   LIB_OBJS += $(OUTPUT)util/dwarf-aux.o
 endif # NO_DWARF
 endif # NO_LIBELF
 ifndef NO_LIBDW_DWARF_UNWIND
   LIB_OBJS += $(OUTPUT)util/unwind-libdw.o
   LIB_H += util/unwind-libdw.h
 endif
 ifndef NO_LIBUNWIND
   LIB_OBJS += $(OUTPUT)util/unwind-libunwind.o
 endif
 LIB_OBJS += $(OUTPUT)tests/keep-tracking.o
 ifndef NO_LIBAUDIT
   BUILTIN_OBJS += $(OUTPUT)builtin-trace.o
 endif
 ifndef NO_SLANG
   LIB_OBJS += $(OUTPUT)ui/browser.o
   LIB_OBJS += $(OUTPUT)ui/browsers/annotate.o
   LIB_OBJS += $(OUTPUT)ui/browsers/hists.o
   LIB_OBJS += $(OUTPUT)ui/browsers/map.o
   LIB_OBJS += $(OUTPUT)ui/browsers/scripts.o
   LIB_OBJS += $(OUTPUT)ui/browsers/header.o
   LIB_OBJS += $(OUTPUT)ui/tui/setup.o
   LIB_OBJS += $(OUTPUT)ui/tui/util.o
   LIB_OBJS += $(OUTPUT)ui/tui/helpline.o
   LIB_OBJS += $(OUTPUT)ui/tui/progress.o
   LIB_H += ui/tui/tui.h
   LIB_H += ui/browser.h
   LIB_H += ui/browsers/map.h
   LIB_H += ui/keysyms.h
   LIB_H += ui/libslang.h
 endif
 ifndef NO_GTK2
   ALL_PROGRAMS += $(OUTPUT)libperf-gtk.so
   GTK_OBJS += $(OUTPUT)ui/gtk/browser.o
   GTK_OBJS += $(OUTPUT)ui/gtk/hists.o
   GTK_OBJS += $(OUTPUT)ui/gtk/setup.o
   GTK_OBJS += $(OUTPUT)ui/gtk/util.o
   GTK_OBJS += $(OUTPUT)ui/gtk/helpline.o
   GTK_OBJS += $(OUTPUT)ui/gtk/progress.o
   GTK_OBJS += $(OUTPUT)ui/gtk/annotate.o
 install-gtk: $(OUTPUT)libperf-gtk.so
 	$(call QUIET_INSTALL, 'GTK UI') \
 		$(INSTALL) -d -m 755 '$(DESTDIR_SQ)$(libdir_SQ)'; \
 		$(INSTALL) $(OUTPUT)libperf-gtk.so '$(DESTDIR_SQ)$(libdir_SQ)'
 endif
 ifndef NO_LIBPERL
   LIB_OBJS += $(OUTPUT)util/scripting-engines/trace-event-perl.o
   LIB_OBJS += $(OUTPUT)scripts/perl/Perf-Trace-Util/Context.o
 endif
 ifndef NO_LIBPYTHON
   LIB_OBJS += $(OUTPUT)util/scripting-engines/trace-event-python.o
   LIB_OBJS += $(OUTPUT)scripts/python/Perf-Trace-Util/Context.o
 endif
 ifeq ($(NO_PERF_REGS),0)
   ifeq ($(ARCH),x86)
     LIB_H += arch/x86/include/perf_regs.h
   endif
   LIB_OBJS += $(OUTPUT)util/perf_regs.o
 endif
 ifndef NO_LIBNUMA
   BUILTIN_OBJS += $(OUTPUT)bench/numa.o
 endif
 ifndef NO_ZLIB
   LIB_OBJS += $(OUTPUT)util/zlib.o
 endif
 ifdef ASCIIDOC8
   export ASCIIDOC8
 endif
 LIBS = -Wl,--whole-archive $(PERFLIBS) -Wl,--no-whole-archive -Wl,--start-group $(EXTLIBS) -Wl,--end-group
 export INSTALL SHELL_PATH
 ### Build rules
 SHELL = $(SHELL_PATH)
 all: shell_compatibility_test $(ALL_PROGRAMS) $(LANG_BINDINGS) $(OTHER_PROGRAMS)
 please_set_SHELL_PATH_to_a_more_modern_shell:
 	@$$(:)
 shell_compatibility_test: please_set_SHELL_PATH_to_a_more_modern_shell
 strip: $(PROGRAMS) $(OUTPUT)perf
 	$(STRIP) $(STRIP_OPTS) $(PROGRAMS) $(OUTPUT)perf
 $(OUTPUT)perf.o: perf.c $(OUTPUT)common-cmds.h $(OUTPUT)PERF-CFLAGS
 	$(QUIET_CC)$(CC) -include $(OUTPUT)PERF-VERSION-FILE \
 		'-DPERF_HTML_PATH="$(htmldir_SQ)"' \
 		$(CFLAGS) -c $(filter %.c,$^) -o $@
 $(OUTPUT)perf: $(OUTPUT)perf.o $(BUILTIN_OBJS) $(PERFLIBS)
 	$(QUIET_LINK)$(CC) $(CFLAGS) $(LDFLAGS) $(OUTPUT)perf.o \
                $(BUILTIN_OBJS) $(LIBS) -o $@
 $(GTK_OBJS): $(OUTPUT)%.o: %.c $(LIB_H)
 	$(QUIET_CC)$(CC) -o $@ -c -fPIC $(CFLAGS) $(GTK_CFLAGS) $<
 $(OUTPUT)libperf-gtk.so: $(GTK_OBJS) $(PERFLIBS)
 	$(QUIET_LINK)$(CC) -o $@ -shared $(LDFLAGS) $(filter %.o,$^) $(GTK_LIBS)
 $(OUTPUT)builtin-help.o: builtin-help.c $(OUTPUT)common-cmds.h $(OUTPUT)PERF-CFLAGS
 	$(QUIET_CC)$(CC) -o $@ -c $(CFLAGS) \
 		'-DPERF_HTML_PATH="$(htmldir_SQ)"' \
 		'-DPERF_MAN_PATH="$(mandir_SQ)"' \
 		'-DPERF_INFO_PATH="$(infodir_SQ)"' $<
 $(OUTPUT)builtin-timechart.o: builtin-timechart.c $(OUTPUT)common-cmds.h $(OUTPUT)PERF-CFLAGS
 	$(QUIET_CC)$(CC) -o $@ -c $(CFLAGS) \
 		'-DPERF_HTML_PATH="$(htmldir_SQ)"' \
 		'-DPERF_MAN_PATH="$(mandir_SQ)"' \
 		'-DPERF_INFO_PATH="$(infodir_SQ)"' $<
 $(OUTPUT)common-cmds.h: util/generate-cmdlist.sh command-list.txt
 $(OUTPUT)common-cmds.h: $(wildcard Documentation/perf-*.txt)
 	$(QUIET_GEN). util/generate-cmdlist.sh > $@+ && mv $@+ $@
 $(SCRIPTS) : % : %.sh
 	$(QUIET_GEN)$(INSTALL) '$@.sh' '$(OUTPUT)$@'
 # These can record PERF_VERSION
 $(OUTPUT)perf.o perf.spec \
 	$(SCRIPTS) \
 	: $(OUTPUT)PERF-VERSION-FILE
 .SUFFIXES:
 #
 # If a target does not match any of the later rules then prefix it by $(OUTPUT)
 # This makes targets like 'make O=/tmp/perf perf.o' work in a natural way.
 #
 ifneq ($(OUTPUT),)
 %.o: $(OUTPUT)%.o
 	@echo "    # Redirected target $@ => $(OUTPUT)$@"
 util/%.o: $(OUTPUT)util/%.o
 	@echo "    # Redirected target $@ => $(OUTPUT)$@"
 bench/%.o: $(OUTPUT)bench/%.o
 	@echo "    # Redirected target $@ => $(OUTPUT)$@"
 tests/%.o: $(OUTPUT)tests/%.o
 	@echo "    # Redirected target $@ => $(OUTPUT)$@"
 endif
 # These two need to be here so that when O= is not used they take precedence
 # over the general rule for .o
 $(OUTPUT)util/%-flex.o: $(OUTPUT)util/%-flex.c $(OUTPUT)PERF-CFLAGS
 	$(QUIET_CC)$(CC) -o $@ -c -Iutil/ $(CFLAGS) -w $<
 $(OUTPUT)util/%-bison.o: $(OUTPUT)util/%-bison.c $(OUTPUT)PERF-CFLAGS
 	$(QUIET_CC)$(CC) -o $@ -c -Iutil/ $(CFLAGS) -DYYENABLE_NLS=0 -DYYLTYPE_IS_TRIVIAL=0 -w $<
 $(OUTPUT)%.o: %.c $(OUTPUT)PERF-CFLAGS
 	$(QUIET_CC)$(CC) -o $@ -c $(CFLAGS) $<
 $(OUTPUT)%.i: %.c $(OUTPUT)PERF-CFLAGS
 	$(QUIET_CC)$(CC) -o $@ -E $(CFLAGS) $<
 $(OUTPUT)%.s: %.c $(OUTPUT)PERF-CFLAGS
 	$(QUIET_CC)$(CC) -o $@ -S $(CFLAGS) $<
 $(OUTPUT)%.o: %.S
 	$(QUIET_CC)$(CC) -o $@ -c $(CFLAGS) $<
 $(OUTPUT)%.s: %.S
 	$(QUIET_CC)$(CC) -o $@ -E $(CFLAGS) $<
 $(OUTPUT)util/exec_cmd.o: util/exec_cmd.c $(OUTPUT)PERF-CFLAGS
 	$(QUIET_CC)$(CC) -o $@ -c $(CFLAGS) \
 		'-DPERF_EXEC_PATH="$(perfexecdir_SQ)"' \
 		'-DPREFIX="$(prefix_SQ)"' \
 		$<
 $(OUTPUT)tests/attr.o: tests/attr.c $(OUTPUT)PERF-CFLAGS
 	$(QUIET_CC)$(CC) -o $@ -c $(CFLAGS) \
 		'-DBINDIR="$(bindir_SQ)"' -DPYTHON='"$(PYTHON_WORD)"' \
 		$<
 $(OUTPUT)tests/python-use.o: tests/python-use.c $(OUTPUT)PERF-CFLAGS
 	$(QUIET_CC)$(CC) -o $@ -c $(CFLAGS) \
 		-DPYTHONPATH='"$(OUTPUT)python"' \
 		-DPYTHON='"$(PYTHON_WORD)"' \
 		$<
 $(OUTPUT)tests/dwarf-unwind.o: tests/dwarf-unwind.c
 	$(QUIET_CC)$(CC) -o $@ -c $(CFLAGS) -fno-optimize-sibling-calls $<
 $(OUTPUT)util/config.o: util/config.c $(OUTPUT)PERF-CFLAGS
 	$(QUIET_CC)$(CC) -o $@ -c $(CFLAGS) -DETC_PERFCONFIG='"$(ETC_PERFCONFIG_SQ)"' $<
 $(OUTPUT)ui/setup.o: ui/setup.c $(OUTPUT)PERF-CFLAGS
 	$(QUIET_CC)$(CC) -o $@ -c $(CFLAGS) -DLIBDIR='"$(libdir_SQ)"' $<
 $(OUTPUT)ui/browser.o: ui/browser.c $(OUTPUT)PERF-CFLAGS
 	$(QUIET_CC)$(CC) -o $@ -c $(CFLAGS) -DENABLE_SLFUTURE_CONST $<
 $(OUTPUT)ui/browsers/annotate.o: ui/browsers/annotate.c $(OUTPUT)PERF-CFLAGS
 	$(QUIET_CC)$(CC) -o $@ -c $(CFLAGS) -DENABLE_SLFUTURE_CONST $<
 $(OUTPUT)ui/browsers/hists.o: ui/browsers/hists.c $(OUTPUT)PERF-CFLAGS
 	$(QUIET_CC)$(CC) -o $@ -c $(CFLAGS) -DENABLE_SLFUTURE_CONST $<
 $(OUTPUT)ui/browsers/map.o: ui/browsers/map.c $(OUTPUT)PERF-CFLAGS
 	$(QUIET_CC)$(CC) -o $@ -c $(CFLAGS) -DENABLE_SLFUTURE_CONST $<
 $(OUTPUT)ui/browsers/scripts.o: ui/browsers/scripts.c $(OUTPUT)PERF-CFLAGS
 	$(QUIET_CC)$(CC) -o $@ -c $(CFLAGS) -DENABLE_SLFUTURE_CONST $<
 $(OUTPUT)util/kallsyms.o: ../lib/symbol/kallsyms.c $(OUTPUT)PERF-CFLAGS
 	$(QUIET_CC)$(CC) -o $@ -c $(CFLAGS) $<
 $(OUTPUT)util/rbtree.o: ../../lib/rbtree.c $(OUTPUT)PERF-CFLAGS
+	$(QUIET_CC)$(CC) -o $@ -c $(CFLAGS) -Wno-unused-parameter -DETC_PERFCONFIG='"$(ETC_PERFCONFIG_SQ)"' $<
+$(OUTPUT)util/hweight.o: ../../lib/hweight.c $(OUTPUT)PERF-CFLAGS
 	$(QUIET_CC)$(CC) -o $@ -c $(CFLAGS) -Wno-unused-parameter -DETC_PERFCONFIG='"$(ETC_PERFCONFIG_SQ)"' $<
 $(OUTPUT)util/find_next_bit.o: ../lib/util/find_next_bit.c $(OUTPUT)PERF-CFLAGS
 	$(QUIET_CC)$(CC) -o $@ -c $(CFLAGS) -Wno-unused-parameter -DETC_PERFCONFIG='"$(ETC_PERFCONFIG_SQ)"' $<
 $(OUTPUT)util/parse-events.o: util/parse-events.c $(OUTPUT)PERF-CFLAGS
 	$(QUIET_CC)$(CC) -o $@ -c $(CFLAGS) -Wno-redundant-decls $<
 $(OUTPUT)util/scripting-engines/trace-event-perl.o: util/scripting-engines/trace-event-perl.c $(OUTPUT)PERF-CFLAGS
 	$(QUIET_CC)$(CC) -o $@ -c $(CFLAGS) $(PERL_EMBED_CCOPTS) -Wno-redundant-decls -Wno-strict-prototypes -Wno-unused-parameter -Wno-shadow -Wno-undef -Wno-switch-default $<
 $(OUTPUT)scripts/perl/Perf-Trace-Util/Context.o: scripts/perl/Perf-Trace-Util/Context.c $(OUTPUT)PERF-CFLAGS
 	$(QUIET_CC)$(CC) -o $@ -c $(CFLAGS) $(PERL_EMBED_CCOPTS) -Wno-redundant-decls -Wno-strict-prototypes -Wno-unused-parameter -Wno-nested-externs -Wno-undef -Wno-switch-default $<
 $(OUTPUT)util/scripting-engines/trace-event-python.o: util/scripting-engines/trace-event-python.c $(OUTPUT)PERF-CFLAGS
 	$(QUIET_CC)$(CC) -o $@ -c $(CFLAGS) $(PYTHON_EMBED_CCOPTS) -Wno-redundant-decls -Wno-strict-prototypes -Wno-unused-parameter -Wno-shadow $<
 $(OUTPUT)scripts/python/Perf-Trace-Util/Context.o: scripts/python/Perf-Trace-Util/Context.c $(OUTPUT)PERF-CFLAGS
 	$(QUIET_CC)$(CC) -o $@ -c $(CFLAGS) $(PYTHON_EMBED_CCOPTS) -Wno-redundant-decls -Wno-strict-prototypes -Wno-unused-parameter -Wno-nested-externs $<
 $(OUTPUT)perf-%: %.o $(PERFLIBS)
 	$(QUIET_LINK)$(CC) $(CFLAGS) -o $@ $(LDFLAGS) $(filter %.o,$^) $(LIBS)
 ifndef NO_PERF_READ_VDSO32
 $(OUTPUT)perf-read-vdso32: perf-read-vdso.c util/find-vdso-map.c
 	$(QUIET_CC)$(CC) -m32 $(filter -static,$(LDFLAGS)) -Wall -Werror -o $@ perf-read-vdso.c
 endif
 ifndef NO_PERF_READ_VDSOX32
 $(OUTPUT)perf-read-vdsox32: perf-read-vdso.c util/find-vdso-map.c
 	$(QUIET_CC)$(CC) -mx32 $(filter -static,$(LDFLAGS)) -Wall -Werror -o $@ perf-read-vdso.c
 endif
 $(LIB_OBJS) $(BUILTIN_OBJS): $(LIB_H)
 $(patsubst perf-%,%.o,$(PROGRAMS)): $(LIB_H) $(wildcard */*.h)
 # we compile into subdirectories. if the target directory is not the source directory, they might not exists. So
 # we depend the various files onto their directories.
 DIRECTORY_DEPS = $(LIB_OBJS) $(BUILTIN_OBJS) $(GTK_OBJS)
 DIRECTORY_DEPS += $(OUTPUT)PERF-VERSION-FILE $(OUTPUT)common-cmds.h
 # no need to add flex objects, because they depend on bison ones
 DIRECTORY_DEPS += $(OUTPUT)util/parse-events-bison.c
 DIRECTORY_DEPS += $(OUTPUT)util/pmu-bison.c
 OUTPUT_DIRECTORIES := $(sort $(dir $(DIRECTORY_DEPS)))
 $(DIRECTORY_DEPS): | $(OUTPUT_DIRECTORIES)
 # In the second step, we make a rule to actually create these directories
 $(OUTPUT_DIRECTORIES):
 	$(QUIET_MKDIR)$(MKDIR) -p $@ 2>/dev/null
 $(LIB_FILE): $(LIB_OBJS)
 	$(QUIET_AR)$(RM) $@ && $(AR) rcs $@ $(LIB_OBJS)
 # libtraceevent.a
 TE_SOURCES = $(wildcard $(TRACE_EVENT_DIR)*.[ch])
 LIBTRACEEVENT_FLAGS  = $(QUIET_SUBDIR1) O=$(OUTPUT)
 LIBTRACEEVENT_FLAGS += CFLAGS="-g -Wall $(EXTRA_CFLAGS)"
 LIBTRACEEVENT_FLAGS += plugin_dir=$(plugindir_SQ)
 $(LIBTRACEEVENT): $(TE_SOURCES) $(OUTPUT)PERF-CFLAGS
 	$(QUIET_SUBDIR0)$(TRACE_EVENT_DIR) $(LIBTRACEEVENT_FLAGS) libtraceevent.a plugins
 $(LIBTRACEEVENT)-clean:
 	$(call QUIET_CLEAN, libtraceevent)
 	@$(MAKE) -C $(TRACE_EVENT_DIR) O=$(OUTPUT) clean >/dev/null
 install-traceevent-plugins: $(LIBTRACEEVENT)
 	$(QUIET_SUBDIR0)$(TRACE_EVENT_DIR) $(LIBTRACEEVENT_FLAGS) install_plugins
 LIBAPIKFS_SOURCES = $(wildcard $(LIB_PATH)fs/*.[ch] $(LIB_PATH)fd/*.[ch])
 # if subdir is set, we've been called from above so target has been built
 # already
 $(LIBAPIKFS): $(LIBAPIKFS_SOURCES)
 ifeq ($(subdir),)
 	$(QUIET_SUBDIR0)$(LIB_DIR) $(QUIET_SUBDIR1) O=$(OUTPUT) libapikfs.a
 endif
 $(LIBAPIKFS)-clean:
 ifeq ($(subdir),)
 	$(call QUIET_CLEAN, libapikfs)
 	@$(MAKE) -C $(LIB_DIR) O=$(OUTPUT) clean >/dev/null
 endif
 help:
 	@echo 'Perf make targets:'
 	@echo '  doc		- make *all* documentation (see below)'
 	@echo '  man		- make manpage documentation (access with man <foo>)'
 	@echo '  html		- make html documentation'
 	@echo '  info		- make GNU info documentation (access with info <foo>)'
 	@echo '  pdf		- make pdf documentation'
 	@echo '  TAGS		- use etags to make tag information for source browsing'
 	@echo '  tags		- use ctags to make tag information for source browsing'
 	@echo '  cscope	- use cscope to make interactive browsing database'
 	@echo ''
 	@echo 'Perf install targets:'
 	@echo '  NOTE: documentation build requires asciidoc, xmlto packages to be installed'
 	@echo '  HINT: use "prefix" or "DESTDIR" to install to a particular'
 	@echo '        path like "make prefix=/usr/local install install-doc"'
 	@echo '  install	- install compiled binaries'
 	@echo '  install-doc	- install *all* documentation'
 	@echo '  install-man	- install manpage documentation'
 	@echo '  install-html	- install html documentation'
 	@echo '  install-info	- install GNU info documentation'
 	@echo '  install-pdf	- install pdf documentation'
 	@echo ''
 	@echo '  quick-install-doc	- alias for quick-install-man'
 	@echo '  quick-install-man	- install the documentation quickly'
 	@echo '  quick-install-html	- install the html documentation quickly'
 	@echo ''
 	@echo 'Perf maintainer targets:'
 	@echo '  clean			- clean all binary objects and build output'
 DOC_TARGETS := doc man html info pdf
 INSTALL_DOC_TARGETS := $(patsubst %,install-%,$(DOC_TARGETS)) try-install-man
 INSTALL_DOC_TARGETS += quick-install-doc quick-install-man quick-install-html
 # 'make doc' should call 'make -C Documentation all'
 $(DOC_TARGETS):
 	$(QUIET_SUBDIR0)Documentation $(QUIET_SUBDIR1) $(@:doc=all)
 TAG_FOLDERS= . ../lib/traceevent ../lib/api ../lib/symbol
 TAG_FILES= ../../include/uapi/linux/perf_event.h
 TAGS:
 	$(QUIET_GEN)$(RM) TAGS; \
 	$(FIND) $(TAG_FOLDERS) -name '*.[hcS]' -print | xargs etags -a $(TAG_FILES)
 tags:
 	$(QUIET_GEN)$(RM) tags; \
 	$(FIND) $(TAG_FOLDERS) -name '*.[hcS]' -print | xargs ctags -a $(TAG_FILES)
 cscope:
 	$(QUIET_GEN)$(RM) cscope*; \
 	$(FIND) $(TAG_FOLDERS) -name '*.[hcS]' -print | xargs cscope -b $(TAG_FILES)
 ### Detect prefix changes
 TRACK_CFLAGS = $(subst ','\'',$(CFLAGS)):\
              $(bindir_SQ):$(perfexecdir_SQ):$(template_dir_SQ):$(prefix_SQ):$(plugindir_SQ)
 $(OUTPUT)PERF-CFLAGS: .FORCE-PERF-CFLAGS
 	@FLAGS='$(TRACK_CFLAGS)'; \
 	    if test x"$$FLAGS" != x"`cat $(OUTPUT)PERF-CFLAGS 2>/dev/null`" ; then \
 		echo 1>&2 "  FLAGS:   * new build flags or prefix"; \
 		echo "$$FLAGS" >$(OUTPUT)PERF-CFLAGS; \
             fi
 ### Testing rules
 # GNU make supports exporting all variables by "export" without parameters.
 # However, the environment gets quite big, and some programs have problems
 # with that.
 check: $(OUTPUT)common-cmds.h
 	if sparse; \
 	then \
 		for i in *.c */*.c; \
 		do \
 			sparse $(CFLAGS) $(SPARSE_FLAGS) $$i || exit; \
 		done; \
 	else \
 		exit 1; \
 	fi
 ### Installation rules
 install-gtk:
 install-bin: all install-gtk
 	$(call QUIET_INSTALL, binaries) \
 		$(INSTALL) -d -m 755 '$(DESTDIR_SQ)$(bindir_SQ)'; \
 		$(INSTALL) $(OUTPUT)perf '$(DESTDIR_SQ)$(bindir_SQ)'; \
 		$(LN) '$(DESTDIR_SQ)$(bindir_SQ)/perf' '$(DESTDIR_SQ)$(bindir_SQ)/trace'
 ifndef NO_PERF_READ_VDSO32
 	$(call QUIET_INSTALL, perf-read-vdso32) \
 		$(INSTALL) $(OUTPUT)perf-read-vdso32 '$(DESTDIR_SQ)$(bindir_SQ)';
 endif
 ifndef NO_PERF_READ_VDSOX32
 	$(call QUIET_INSTALL, perf-read-vdsox32) \
 		$(INSTALL) $(OUTPUT)perf-read-vdsox32 '$(DESTDIR_SQ)$(bindir_SQ)';
 endif
 	$(call QUIET_INSTALL, libexec) \
 		$(INSTALL) -d -m 755 '$(DESTDIR_SQ)$(perfexec_instdir_SQ)'
 	$(call QUIET_INSTALL, perf-archive) \
 		$(INSTALL) $(OUTPUT)perf-archive -t '$(DESTDIR_SQ)$(perfexec_instdir_SQ)'
 	$(call QUIET_INSTALL, perf-with-kcore) \
 		$(INSTALL) $(OUTPUT)perf-with-kcore -t '$(DESTDIR_SQ)$(perfexec_instdir_SQ)'
 ifndef NO_LIBPERL
 	$(call QUIET_INSTALL, perl-scripts) \
 		$(INSTALL) -d -m 755 '$(DESTDIR_SQ)$(perfexec_instdir_SQ)/scripts/perl/Perf-Trace-Util/lib/Perf/Trace'; \
 		$(INSTALL) scripts/perl/Perf-Trace-Util/lib/Perf/Trace/* -t '$(DESTDIR_SQ)$(perfexec_instdir_SQ)/scripts/perl/Perf-Trace-Util/lib/Perf/Trace'; \
 		$(INSTALL) scripts/perl/*.pl -t '$(DESTDIR_SQ)$(perfexec_instdir_SQ)/scripts/perl'; \
 		$(INSTALL) -d -m 755 '$(DESTDIR_SQ)$(perfexec_instdir_SQ)/scripts/perl/bin'; \
 		$(INSTALL) scripts/perl/bin/* -t '$(DESTDIR_SQ)$(perfexec_instdir_SQ)/scripts/perl/bin'
 endif
 ifndef NO_LIBPYTHON
 	$(call QUIET_INSTALL, python-scripts) \
 		$(INSTALL) -d -m 755 '$(DESTDIR_SQ)$(perfexec_instdir_SQ)/scripts/python/Perf-Trace-Util/lib/Perf/Trace'; \
 		$(INSTALL) -d -m 755 '$(DESTDIR_SQ)$(perfexec_instdir_SQ)/scripts/python/bin'; \
 		$(INSTALL) scripts/python/Perf-Trace-Util/lib/Perf/Trace/* -t '$(DESTDIR_SQ)$(perfexec_instdir_SQ)/scripts/python/Perf-Trace-Util/lib/Perf/Trace'; \
 		$(INSTALL) scripts/python/*.py -t '$(DESTDIR_SQ)$(perfexec_instdir_SQ)/scripts/python'; \
 		$(INSTALL) scripts/python/bin/* -t '$(DESTDIR_SQ)$(perfexec_instdir_SQ)/scripts/python/bin'
 endif
 	$(call QUIET_INSTALL, perf_completion-script) \
 		$(INSTALL) -d -m 755 '$(DESTDIR_SQ)$(sysconfdir_SQ)/bash_completion.d'; \
 		$(INSTALL) perf-completion.sh '$(DESTDIR_SQ)$(sysconfdir_SQ)/bash_completion.d/perf'
 	$(call QUIET_INSTALL, tests) \
 		$(INSTALL) -d -m 755 '$(DESTDIR_SQ)$(perfexec_instdir_SQ)/tests'; \
 		$(INSTALL) tests/attr.py '$(DESTDIR_SQ)$(perfexec_instdir_SQ)/tests'; \
 		$(INSTALL) -d -m 755 '$(DESTDIR_SQ)$(perfexec_instdir_SQ)/tests/attr'; \
 		$(INSTALL) tests/attr/* '$(DESTDIR_SQ)$(perfexec_instdir_SQ)/tests/attr'
 install: install-bin try-install-man install-traceevent-plugins
 install-python_ext:
 	$(PYTHON_WORD) util/setup.py --quiet install --root='/$(DESTDIR_SQ)'
 # 'make install-doc' should call 'make -C Documentation install'
 $(INSTALL_DOC_TARGETS):
 	$(QUIET_SUBDIR0)Documentation $(QUIET_SUBDIR1) $(@:-doc=)
 ### Cleaning rules
 #
 # This is here, not in config/Makefile, because config/Makefile does
 # not get included for the clean target:
 #
 config-clean:
 	$(call QUIET_CLEAN, config)
 	@$(MAKE) -C config/feature-checks clean >/dev/null
 clean: $(LIBTRACEEVENT)-clean $(LIBAPIKFS)-clean config-clean
 	$(call QUIET_CLEAN, core-objs)  $(RM) $(LIB_OBJS) $(BUILTIN_OBJS) $(LIB_FILE) $(OUTPUT)perf-archive $(OUTPUT)perf-with-kcore $(OUTPUT)perf.o $(LANG_BINDINGS) $(GTK_OBJS)
 	$(call QUIET_CLEAN, core-progs) $(RM) $(ALL_PROGRAMS) perf perf-read-vdso32 perf-read-vdsox32
 	$(call QUIET_CLEAN, core-gen)   $(RM)  *.spec *.pyc *.pyo */*.pyc */*.pyo $(OUTPUT)common-cmds.h TAGS tags cscope* $(OUTPUT)PERF-VERSION-FILE $(OUTPUT)PERF-CFLAGS $(OUTPUT)PERF-FEATURES $(OUTPUT)util/*-bison* $(OUTPUT)util/*-flex*
 	$(QUIET_SUBDIR0)Documentation $(QUIET_SUBDIR1) clean
 	$(python-clean)
 #
 # Trick: if ../../.git does not exist - we are building out of tree for example,
 # then force version regeneration:
 #
 ifeq ($(wildcard ../../.git/HEAD),)
     GIT-HEAD-PHONY = ../../.git/HEAD
 else
     GIT-HEAD-PHONY =
 endif
 .PHONY: all install clean config-clean strip install-gtk
 .PHONY: shell_compatibility_test please_set_SHELL_PATH_to_a_more_modern_shell
 .PHONY: $(GIT-HEAD-PHONY) TAGS tags cscope .FORCE-PERF-CFLAGS

tools/perf/arch/powerpc/util/skip-callchain-idx.c

Diff comments View file @ 59b2858

 /*
  * Use DWARF Debug information to skip unnecessary callchain entries.
  *
  * Copyright (C) 2014 Sukadev Bhattiprolu, IBM Corporation.
  * Copyright (C) 2014 Ulrich Weigand, IBM Corporation.
  *
  * This program is free software; you can redistribute it and/or
  * modify it under the terms of the GNU General Public License
  * as published by the Free Software Foundation; either version
  * 2 of the License, or (at your option) any later version.
  */
 #include <inttypes.h>
 #include <dwarf.h>
 #include <elfutils/libdwfl.h>
 #include "util/thread.h"
 #include "util/callchain.h"
 #include "util/debug.h"
 /*
  * When saving the callchain on Power, the kernel conservatively saves
  * excess entries in the callchain. A few of these entries are needed
  * in some cases but not others. If the unnecessary entries are not
  * ignored, we end up with duplicate arcs in the call-graphs. Use
  * DWARF debug information to skip over any unnecessary callchain
  * entries.
  *
  * See function header for arch_adjust_callchain() below for more details.
  *
  * The libdwfl code in this file is based on code from elfutils
  * (libdwfl/argp-std.c, libdwfl/tests/addrcfi.c, etc).
  */
 static char *debuginfo_path;
 static const Dwfl_Callbacks offline_callbacks = {
 	.debuginfo_path = &debuginfo_path,
 	.find_debuginfo = dwfl_standard_find_debuginfo,
 	.section_address = dwfl_offline_section_address,
 };
 /*
  * Use the DWARF expression for the Call-frame-address and determine
  * if return address is in LR and if a new frame was allocated.
  */
 static int check_return_reg(int ra_regno, Dwarf_Frame *frame)
 {
 	Dwarf_Op ops_mem[2];
 	Dwarf_Op dummy;
 	Dwarf_Op *ops = &dummy;
 	size_t nops;
 	int result;
 	result = dwarf_frame_register(frame, ra_regno, ops_mem, &ops, &nops);
 	if (result < 0) {
 		pr_debug("dwarf_frame_register() %s\n", dwarf_errmsg(-1));
 		return -1;
 	}
 	/*
 	 * Check if return address is on the stack.
 	 */
 	if (nops != 0 || ops != NULL)
 		return 0;
 	/*
 	 * Return address is in LR. Check if a frame was allocated
 	 * but not-yet used.
 	 */
 	result = dwarf_frame_cfa(frame, &ops, &nops);
 	if (result < 0) {
 		pr_debug("dwarf_frame_cfa() returns %d, %s\n", result,
 					dwarf_errmsg(-1));
 		return -1;
 	}
 	/*
 	 * If call frame address is in r1, no new frame was allocated.
 	 */
 	if (nops == 1 && ops[0].atom == DW_OP_bregx && ops[0].number == 1 &&
 				ops[0].number2 == 0)
 		return 1;
 	/*
 	 * A new frame was allocated but has not yet been used.
 	 */
 	return 2;
 }
 /*
  * Get the DWARF frame from the .eh_frame section.
  */
 static Dwarf_Frame *get_eh_frame(Dwfl_Module *mod, Dwarf_Addr pc)
 {
 	int		result;
 	Dwarf_Addr	bias;
 	Dwarf_CFI	*cfi;
 	Dwarf_Frame	*frame;
 	cfi = dwfl_module_eh_cfi(mod, &bias);
 	if (!cfi) {
 		pr_debug("%s(): no CFI - %s\n", __func__, dwfl_errmsg(-1));
 		return NULL;
 	}
-	result = dwarf_cfi_addrframe(cfi, pc, &frame);
+	result = dwarf_cfi_addrframe(cfi, pc-bias, &frame);
 	if (result) {
 		pr_debug("%s(): %s\n", __func__, dwfl_errmsg(-1));
 		return NULL;
 	}
 	return frame;
 }
 /*
  * Get the DWARF frame from the .debug_frame section.
  */
 static Dwarf_Frame *get_dwarf_frame(Dwfl_Module *mod, Dwarf_Addr pc)
 {
 	Dwarf_CFI       *cfi;
 	Dwarf_Addr      bias;
 	Dwarf_Frame     *frame;
 	int             result;
 	cfi = dwfl_module_dwarf_cfi(mod, &bias);
 	if (!cfi) {
 		pr_debug("%s(): no CFI - %s\n", __func__, dwfl_errmsg(-1));
 		return NULL;
 	}
-	result = dwarf_cfi_addrframe(cfi, pc, &frame);
+	result = dwarf_cfi_addrframe(cfi, pc-bias, &frame);
 	if (result) {
 		pr_debug("%s(): %s\n", __func__, dwfl_errmsg(-1));
 		return NULL;
 	}
 	return frame;
 }
 /*
  * Return:
  *	0 if return address for the program counter @pc is on stack
  *	1 if return address is in LR and no new stack frame was allocated
  *	2 if return address is in LR and a new frame was allocated (but not
  *		yet used)
  *	-1 in case of errors
  */
-static int check_return_addr(struct dso *dso, Dwarf_Addr pc)
+static int check_return_addr(struct dso *dso, u64 map_start, Dwarf_Addr pc)
 {
 	int		rc = -1;
 	Dwfl		*dwfl;
 	Dwfl_Module	*mod;
 	Dwarf_Frame	*frame;
 	int		ra_regno;
 	Dwarf_Addr	start = pc;
 	Dwarf_Addr	end = pc;
 	bool		signalp;
+	const char	*exec_file = dso->long_name;
 	dwfl = dso->dwfl;
 	if (!dwfl) {
 		dwfl = dwfl_begin(&offline_callbacks);
 		if (!dwfl) {
 			pr_debug("dwfl_begin() failed: %s\n", dwarf_errmsg(-1));
 			return -1;
 		}
-		if (dwfl_report_offline(dwfl, "", dso->long_name, -1) == NULL) {
+		mod = dwfl_report_elf(dwfl, exec_file, exec_file, -1,
-			pr_debug("dwfl_report_offline() failed %s\n",
+						map_start, false);
+		if (!mod) {
+			pr_debug("dwfl_report_elf() failed %s\n",
 						dwarf_errmsg(-1));
 			/*
 			 * We normally cache the DWARF debug info and never
 			 * call dwfl_end(). But to prevent fd leak, free in
 			 * case of error.
 			 */
 			dwfl_end(dwfl);
 			goto out;
 		}
 		dso->dwfl = dwfl;
 	}
 	mod = dwfl_addrmodule(dwfl, pc);
 	if (!mod) {
 		pr_debug("dwfl_addrmodule() failed, %s\n", dwarf_errmsg(-1));
 		goto out;
 	}
 	/*
 	 * To work with split debug info files (eg: glibc), check both
 	 * .eh_frame and .debug_frame sections of the ELF header.
 	 */
 	frame = get_eh_frame(mod, pc);
 	if (!frame) {
 		frame = get_dwarf_frame(mod, pc);
 		if (!frame)
 			goto out;
 	}
 	ra_regno = dwarf_frame_info(frame, &start, &end, &signalp);
 	if (ra_regno < 0) {
 		pr_debug("Return address register unavailable: %s\n",
 				dwarf_errmsg(-1));
 		goto out;
 	}
 	rc = check_return_reg(ra_regno, frame);
 out:
 	return rc;
 }
 /*
  * The callchain saved by the kernel always includes the link register (LR).
  *
  *	0:	PERF_CONTEXT_USER
  *	1:	Program counter (Next instruction pointer)
  *	2:	LR value
  *	3:	Caller's caller
  *	4:	...
  *
  * The value in LR is only needed when it holds a return address. If the
  * return address is on the stack, we should ignore the LR value.
  *
  * Further, when the return address is in the LR, if a new frame was just
  * allocated but the LR was not saved into it, then the LR contains the
  * caller, slot 4: contains the caller's caller and the contents of slot 3:
  * (chain->ips[3]) is undefined and must be ignored.
  *
  * Use DWARF debug information to determine if any entries need to be skipped.
  *
  * Return:
  *	index:	of callchain entry that needs to be ignored (if any)
  *	-1	if no entry needs to be ignored or in case of errors
  */
 int arch_skip_callchain_idx(struct thread *thread, struct ip_callchain *chain)
 {
 	struct addr_location al;
 	struct dso *dso = NULL;
 	int rc;
 	u64 ip;
 	u64 skip_slot = -1;
 	if (chain->nr < 3)
 		return skip_slot;
 	ip = chain->ips[2];
 	thread__find_addr_location(thread, PERF_RECORD_MISC_USER,
 			MAP__FUNCTION, ip, &al);
 	if (al.map)
 		dso = al.map->dso;
 	if (!dso) {
 		pr_debug("%" PRIx64 " dso is NULL\n", ip);
 		return skip_slot;
 	}
-	rc = check_return_addr(dso, ip);
+	rc = check_return_addr(dso, al.map->start, ip);
-	pr_debug("DSO %s, nr %" PRIx64 ", ip 0x%" PRIx64 "rc %d\n",
+	pr_debug("[DSO %s, sym %s, ip 0x%" PRIx64 "] rc %d\n",
-				dso->long_name, chain->nr, ip, rc);
+				dso->long_name, al.sym->name, ip, rc);
 	if (rc == 0) {
 		/*
 		 * Return address on stack. Ignore LR value in callchain
 		 */
 		skip_slot = 2;
 	} else if (rc == 2) {
 		/*
 		 * New frame allocated but return address still in LR.
 		 * Ignore the caller's caller entry in callchain.
 		 */
 		skip_slot = 3;
 	}
 	return skip_slot;
 }

tools/perf/bench/sched-pipe.c

Diff comments View file @ 59b2858

 /*
  *
  * sched-pipe.c
  *
  * pipe: Benchmark for pipe()
  *
  * Based on pipe-test-1m.c by Ingo Molnar <mingo@redhat.com>
  *  http://people.redhat.com/mingo/cfs-scheduler/tools/pipe-test-1m.c
  * Ported to perf by Hitoshi Mitake <mitake@dcl.info.waseda.ac.jp>
  */
 #include "../perf.h"
 #include "../util/util.h"
 #include "../util/parse-options.h"
 #include "../builtin.h"
 #include "bench.h"
 #include <unistd.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <signal.h>
 #include <sys/wait.h>
-#include <linux/unistd.h>
 #include <string.h>
 #include <errno.h>
 #include <assert.h>
 #include <sys/time.h>
 #include <sys/types.h>
+#include <sys/syscall.h>
 #include <pthread.h>
 struct thread_data {
 	int			nr;
 	int			pipe_read;
 	int			pipe_write;
 	pthread_t		pthread;
 };
 #define LOOPS_DEFAULT 1000000
 static	int			loops = LOOPS_DEFAULT;
 /* Use processes by default: */
 static bool			threaded;
 static const struct option options[] = {
 	OPT_INTEGER('l', "loop",	&loops,		"Specify number of loops"),
 	OPT_BOOLEAN('T', "threaded",	&threaded,	"Specify threads/process based task setup"),
 	OPT_END()
 };
 static const char * const bench_sched_pipe_usage[] = {
 	"perf bench sched pipe <options>",
 	NULL
 };
 static void *worker_thread(void *__tdata)
 {
 	struct thread_data *td = __tdata;
 	int m = 0, i;
 	int ret;
 	for (i = 0; i < loops; i++) {
 		if (!td->nr) {
 			ret = read(td->pipe_read, &m, sizeof(int));
 			BUG_ON(ret != sizeof(int));
 			ret = write(td->pipe_write, &m, sizeof(int));
 			BUG_ON(ret != sizeof(int));
 		} else {
 			ret = write(td->pipe_write, &m, sizeof(int));
 			BUG_ON(ret != sizeof(int));
 			ret = read(td->pipe_read, &m, sizeof(int));
 			BUG_ON(ret != sizeof(int));
 		}
 	}
 	return NULL;
 }
 int bench_sched_pipe(int argc, const char **argv, const char *prefix __maybe_unused)
 {
 	struct thread_data threads[2], *td;
 	int pipe_1[2], pipe_2[2];
 	struct timeval start, stop, diff;
 	unsigned long long result_usec = 0;
 	int nr_threads = 2;
 	int t;
 	/*
 	 * why does "ret" exist?
 	 * discarding returned value of read(), write()
 	 * causes error in building environment for perf
 	 */
 	int __maybe_unused ret, wait_stat;
 	pid_t pid, retpid __maybe_unused;
 	argc = parse_options(argc, argv, options, bench_sched_pipe_usage, 0);
 	BUG_ON(pipe(pipe_1));
 	BUG_ON(pipe(pipe_2));
 	gettimeofday(&start, NULL);
 	for (t = 0; t < nr_threads; t++) {
 		td = threads + t;
 		td->nr = t;
 		if (t == 0) {
 			td->pipe_read = pipe_1[0];
 			td->pipe_write = pipe_2[1];
 		} else {
 			td->pipe_write = pipe_1[1];
 			td->pipe_read = pipe_2[0];
 		}
 	}
 	if (threaded) {
 		for (t = 0; t < nr_threads; t++) {
 			td = threads + t;
 			ret = pthread_create(&td->pthread, NULL, worker_thread, td);
 			BUG_ON(ret);
 		}
 		for (t = 0; t < nr_threads; t++) {
 			td = threads + t;
 			ret = pthread_join(td->pthread, NULL);
 			BUG_ON(ret);
 		}
 	} else {
 		pid = fork();
 		assert(pid >= 0);
 		if (!pid) {
 			worker_thread(threads + 0);
 			exit(0);
 		} else {
 			worker_thread(threads + 1);
 		}
 		retpid = waitpid(pid, &wait_stat, 0);
 		assert((retpid == pid) && WIFEXITED(wait_stat));
 	}
 	gettimeofday(&stop, NULL);
 	timersub(&stop, &start, &diff);
 	switch (bench_format) {
 	case BENCH_FORMAT_DEFAULT:
 		printf("# Executed %d pipe operations between two %s\n\n",
 			loops, threaded ? "threads" : "processes");
 		result_usec = diff.tv_sec * 1000000;
 		result_usec += diff.tv_usec;
 		printf(" %14s: %lu.%03lu [sec]\n\n", "Total time",
 		       diff.tv_sec,
 		       (unsigned long) (diff.tv_usec/1000));
 		printf(" %14lf usecs/op\n",
 		       (double)result_usec / (double)loops);
 		printf(" %14d ops/sec\n",
 		       (int)((double)loops /
 			     ((double)result_usec / (double)1000000)));
 		break;
 	case BENCH_FORMAT_SIMPLE:
 		printf("%lu.%03lu\n",
 		       diff.tv_sec,
 		       (unsigned long) (diff.tv_usec / 1000));
 		break;
 	default:
 		/* reaching here is something disaster */
 		fprintf(stderr, "Unknown format:%d\n", bench_format);
 		exit(1);
 		break;
 	}
 	return 0;
 }

tools/perf/builtin-top.c

Diff comments View file @ 59b2858

 /*
  * builtin-top.c
  *
  * Builtin top command: Display a continuously updated profile of
  * any workload, CPU or specific PID.
  *
  * Copyright (C) 2008, Red Hat Inc, Ingo Molnar <mingo@redhat.com>
  *		 2011, Red Hat Inc, Arnaldo Carvalho de Melo <acme@redhat.com>
  *
  * Improvements and fixes by:
  *
  *   Arjan van de Ven <arjan@linux.intel.com>
  *   Yanmin Zhang <yanmin.zhang@intel.com>
  *   Wu Fengguang <fengguang.wu@intel.com>
  *   Mike Galbraith <efault@gmx.de>
  *   Paul Mackerras <paulus@samba.org>
  *
  * Released under the GPL v2. (and only v2, not any later version)
  */
 #include "builtin.h"
 #include "perf.h"
 #include "util/annotate.h"
 #include "util/cache.h"
 #include "util/color.h"
 #include "util/evlist.h"
 #include "util/evsel.h"
 #include "util/machine.h"
 #include "util/session.h"
 #include "util/symbol.h"
 #include "util/thread.h"
 #include "util/thread_map.h"
 #include "util/top.h"
 #include "util/util.h"
 #include <linux/rbtree.h>
 #include "util/parse-options.h"
 #include "util/parse-events.h"
 #include "util/cpumap.h"
 #include "util/xyarray.h"
 #include "util/sort.h"
 #include "util/intlist.h"
 #include "arch/common.h"
 #include "util/debug.h"
 #include <assert.h>
 #include <elf.h>
 #include <fcntl.h>
 #include <stdio.h>
 #include <termios.h>
 #include <unistd.h>
 #include <inttypes.h>
 #include <errno.h>
 #include <time.h>
 #include <sched.h>
 #include <sys/syscall.h>
 #include <sys/ioctl.h>
 #include <poll.h>
 #include <sys/prctl.h>
 #include <sys/wait.h>
 #include <sys/uio.h>
 #include <sys/utsname.h>
 #include <sys/mman.h>
-#include <linux/unistd.h>
 #include <linux/types.h>
 static volatile int done;
 #define HEADER_LINE_NR  5
 static void perf_top__update_print_entries(struct perf_top *top)
 {
 	top->print_entries = top->winsize.ws_row - HEADER_LINE_NR;
 }
 static void perf_top__sig_winch(int sig __maybe_unused,
 				siginfo_t *info __maybe_unused, void *arg)
 {
 	struct perf_top *top = arg;
 	get_term_dimensions(&top->winsize);
 	perf_top__update_print_entries(top);
 }
 static int perf_top__parse_source(struct perf_top *top, struct hist_entry *he)
 {
 	struct symbol *sym;
 	struct annotation *notes;
 	struct map *map;
 	int err = -1;
 	if (!he || !he->ms.sym)
 		return -1;
 	sym = he->ms.sym;
 	map = he->ms.map;
 	/*
 	 * We can't annotate with just /proc/kallsyms
 	 */
 	if (map->dso->symtab_type == DSO_BINARY_TYPE__KALLSYMS &&
 	    !dso__is_kcore(map->dso)) {
 		pr_err("Can't annotate %s: No vmlinux file was found in the "
 		       "path\n", sym->name);
 		sleep(1);
 		return -1;
 	}
 	notes = symbol__annotation(sym);
 	if (notes->src != NULL) {
 		pthread_mutex_lock(&notes->lock);
 		goto out_assign;
 	}
 	pthread_mutex_lock(&notes->lock);
 	if (symbol__alloc_hist(sym) < 0) {
 		pthread_mutex_unlock(&notes->lock);
 		pr_err("Not enough memory for annotating '%s' symbol!\n",
 		       sym->name);
 		sleep(1);
 		return err;
 	}
 	err = symbol__annotate(sym, map, 0);
 	if (err == 0) {
 out_assign:
 		top->sym_filter_entry = he;
 	}
 	pthread_mutex_unlock(&notes->lock);
 	return err;
 }
 static void __zero_source_counters(struct hist_entry *he)
 {
 	struct symbol *sym = he->ms.sym;
 	symbol__annotate_zero_histograms(sym);
 }
 static void ui__warn_map_erange(struct map *map, struct symbol *sym, u64 ip)
 {
 	struct utsname uts;
 	int err = uname(&uts);
 	ui__warning("Out of bounds address found:\n\n"
 		    "Addr:   %" PRIx64 "\n"
 		    "DSO:    %s %c\n"
 		    "Map:    %" PRIx64 "-%" PRIx64 "\n"
 		    "Symbol: %" PRIx64 "-%" PRIx64 " %c %s\n"
 		    "Arch:   %s\n"
 		    "Kernel: %s\n"
 		    "Tools:  %s\n\n"
 		    "Not all samples will be on the annotation output.\n\n"
 		    "Please report to linux-kernel@vger.kernel.org\n",
 		    ip, map->dso->long_name, dso__symtab_origin(map->dso),
 		    map->start, map->end, sym->start, sym->end,
 		    sym->binding == STB_GLOBAL ? 'g' :
 		    sym->binding == STB_LOCAL  ? 'l' : 'w', sym->name,
 		    err ? "[unknown]" : uts.machine,
 		    err ? "[unknown]" : uts.release, perf_version_string);
 	if (use_browser <= 0)
 		sleep(5);
 	map->erange_warned = true;
 }
 static void perf_top__record_precise_ip(struct perf_top *top,
 					struct hist_entry *he,
 					int counter, u64 ip)
 {
 	struct annotation *notes;
 	struct symbol *sym;
 	int err = 0;
 	if (he == NULL || he->ms.sym == NULL ||
 	    ((top->sym_filter_entry == NULL ||
 	      top->sym_filter_entry->ms.sym != he->ms.sym) && use_browser != 1))
 		return;
 	sym = he->ms.sym;
 	notes = symbol__annotation(sym);
 	if (pthread_mutex_trylock(&notes->lock))
 		return;
 	ip = he->ms.map->map_ip(he->ms.map, ip);
 	if (ui__has_annotation())
 		err = hist_entry__inc_addr_samples(he, counter, ip);
 	pthread_mutex_unlock(&notes->lock);
 	/*
 	 * This function is now called with he->hists->lock held.
 	 * Release it before going to sleep.
 	 */
 	pthread_mutex_unlock(&he->hists->lock);
 	if (err == -ERANGE && !he->ms.map->erange_warned)
 		ui__warn_map_erange(he->ms.map, sym, ip);
 	else if (err == -ENOMEM) {
 		pr_err("Not enough memory for annotating '%s' symbol!\n",
 		       sym->name);
 		sleep(1);
 	}
 	pthread_mutex_lock(&he->hists->lock);
 }
 static void perf_top__show_details(struct perf_top *top)
 {
 	struct hist_entry *he = top->sym_filter_entry;
 	struct annotation *notes;
 	struct symbol *symbol;
 	int more;
 	if (!he)
 		return;
 	symbol = he->ms.sym;
 	notes = symbol__annotation(symbol);
 	pthread_mutex_lock(&notes->lock);
 	if (notes->src == NULL)
 		goto out_unlock;
 	printf("Showing %s for %s\n", perf_evsel__name(top->sym_evsel), symbol->name);
 	printf("  Events  Pcnt (>=%d%%)\n", top->sym_pcnt_filter);
 	more = symbol__annotate_printf(symbol, he->ms.map, top->sym_evsel,
 				       0, top->sym_pcnt_filter, top->print_entries, 4);
 	if (top->zero)
 		symbol__annotate_zero_histogram(symbol, top->sym_evsel->idx);
 	else
 		symbol__annotate_decay_histogram(symbol, top->sym_evsel->idx);
 	if (more != 0)
 		printf("%d lines not displayed, maybe increase display entries [e]\n", more);
 out_unlock:
 	pthread_mutex_unlock(&notes->lock);
 }
 static void perf_top__print_sym_table(struct perf_top *top)
 {
 	char bf[160];
 	int printed = 0;
 	const int win_width = top->winsize.ws_col - 1;
 	struct hists *hists = evsel__hists(top->sym_evsel);
 	puts(CONSOLE_CLEAR);
 	perf_top__header_snprintf(top, bf, sizeof(bf));
 	printf("%s\n", bf);
 	perf_top__reset_sample_counters(top);
 	printf("%-*.*s\n", win_width, win_width, graph_dotted_line);
 	if (hists->stats.nr_lost_warned !=
 	    hists->stats.nr_events[PERF_RECORD_LOST]) {
 		hists->stats.nr_lost_warned =
 			      hists->stats.nr_events[PERF_RECORD_LOST];
 		color_fprintf(stdout, PERF_COLOR_RED,
 			      "WARNING: LOST %d chunks, Check IO/CPU overload",
 			      hists->stats.nr_lost_warned);
 		++printed;
 	}
 	if (top->sym_filter_entry) {
 		perf_top__show_details(top);
 		return;
 	}
 	if (top->zero) {
 		hists__delete_entries(hists);
 	} else {
 		hists__decay_entries(hists, top->hide_user_symbols,
 				     top->hide_kernel_symbols);
 	}
 	hists__collapse_resort(hists, NULL);
 	hists__output_resort(hists, NULL);
 	hists__output_recalc_col_len(hists, top->print_entries - printed);
 	putchar('\n');
 	hists__fprintf(hists, false, top->print_entries - printed, win_width,
 		       top->min_percent, stdout);
 }
 static void prompt_integer(int *target, const char *msg)
 {
 	char *buf = malloc(0), *p;
 	size_t dummy = 0;
 	int tmp;
 	fprintf(stdout, "\n%s: ", msg);
 	if (getline(&buf, &dummy, stdin) < 0)
 		return;
 	p = strchr(buf, '\n');
 	if (p)
 		*p = 0;
 	p = buf;
 	while(*p) {
 		if (!isdigit(*p))
 			goto out_free;
 		p++;
 	}
 	tmp = strtoul(buf, NULL, 10);
 	*target = tmp;
 out_free:
 	free(buf);
 }
 static void prompt_percent(int *target, const char *msg)
 {
 	int tmp = 0;
 	prompt_integer(&tmp, msg);
 	if (tmp >= 0 && tmp <= 100)
 		*target = tmp;
 }
 static void perf_top__prompt_symbol(struct perf_top *top, const char *msg)
 {
 	char *buf = malloc(0), *p;
 	struct hist_entry *syme = top->sym_filter_entry, *n, *found = NULL;
 	struct hists *hists = evsel__hists(top->sym_evsel);
 	struct rb_node *next;
 	size_t dummy = 0;
 	/* zero counters of active symbol */
 	if (syme) {
 		__zero_source_counters(syme);
 		top->sym_filter_entry = NULL;
 	}
 	fprintf(stdout, "\n%s: ", msg);
 	if (getline(&buf, &dummy, stdin) < 0)
 		goto out_free;
 	p = strchr(buf, '\n');
 	if (p)
 		*p = 0;
 	next = rb_first(&hists->entries);
 	while (next) {
 		n = rb_entry(next, struct hist_entry, rb_node);
 		if (n->ms.sym && !strcmp(buf, n->ms.sym->name)) {
 			found = n;
 			break;
 		}
 		next = rb_next(&n->rb_node);
 	}
 	if (!found) {
 		fprintf(stderr, "Sorry, %s is not active.\n", buf);
 		sleep(1);
 	} else
 		perf_top__parse_source(top, found);
 out_free:
 	free(buf);
 }
 static void perf_top__print_mapped_keys(struct perf_top *top)
 {
 	char *name = NULL;
 	if (top->sym_filter_entry) {
 		struct symbol *sym = top->sym_filter_entry->ms.sym;
 		name = sym->name;
 	}
 	fprintf(stdout, "\nMapped keys:\n");
 	fprintf(stdout, "\t[d]     display refresh delay.             \t(%d)\n", top->delay_secs);
 	fprintf(stdout, "\t[e]     display entries (lines).           \t(%d)\n", top->print_entries);
 	if (top->evlist->nr_entries > 1)
 		fprintf(stdout, "\t[E]     active event counter.              \t(%s)\n", perf_evsel__name(top->sym_evsel));
 	fprintf(stdout, "\t[f]     profile display filter (count).    \t(%d)\n", top->count_filter);
 	fprintf(stdout, "\t[F]     annotate display filter (percent). \t(%d%%)\n", top->sym_pcnt_filter);
 	fprintf(stdout, "\t[s]     annotate symbol.                   \t(%s)\n", name?: "NULL");
 	fprintf(stdout, "\t[S]     stop annotation.\n");
 	fprintf(stdout,
 		"\t[K]     hide kernel_symbols symbols.     \t(%s)\n",
 		top->hide_kernel_symbols ? "yes" : "no");
 	fprintf(stdout,
 		"\t[U]     hide user symbols.               \t(%s)\n",
 		top->hide_user_symbols ? "yes" : "no");
 	fprintf(stdout, "\t[z]     toggle sample zeroing.             \t(%d)\n", top->zero ? 1 : 0);
 	fprintf(stdout, "\t[qQ]    quit.\n");
 }
 static int perf_top__key_mapped(struct perf_top *top, int c)
 {
 	switch (c) {
 		case 'd':
 		case 'e':
 		case 'f':
 		case 'z':
 		case 'q':
 		case 'Q':
 		case 'K':
 		case 'U':
 		case 'F':
 		case 's':
 		case 'S':
 			return 1;
 		case 'E':
 			return top->evlist->nr_entries > 1 ? 1 : 0;
 		default:
 			break;
 	}
 	return 0;
 }
 static bool perf_top__handle_keypress(struct perf_top *top, int c)
 {
 	bool ret = true;
 	if (!perf_top__key_mapped(top, c)) {
 		struct pollfd stdin_poll = { .fd = 0, .events = POLLIN };
 		struct termios save;
 		perf_top__print_mapped_keys(top);
 		fprintf(stdout, "\nEnter selection, or unmapped key to continue: ");
 		fflush(stdout);
 		set_term_quiet_input(&save);
 		poll(&stdin_poll, 1, -1);
 		c = getc(stdin);
 		tcsetattr(0, TCSAFLUSH, &save);
 		if (!perf_top__key_mapped(top, c))
 			return ret;
 	}
 	switch (c) {
 		case 'd':
 			prompt_integer(&top->delay_secs, "Enter display delay");
 			if (top->delay_secs < 1)
 				top->delay_secs = 1;
 			break;
 		case 'e':
 			prompt_integer(&top->print_entries, "Enter display entries (lines)");
 			if (top->print_entries == 0) {
 				struct sigaction act = {
 					.sa_sigaction = perf_top__sig_winch,
 					.sa_flags     = SA_SIGINFO,
 				};
 				perf_top__sig_winch(SIGWINCH, NULL, top);
 				sigaction(SIGWINCH, &act, NULL);
 			} else {
 				signal(SIGWINCH, SIG_DFL);
 			}
 			break;
 		case 'E':
 			if (top->evlist->nr_entries > 1) {
 				/* Select 0 as the default event: */
 				int counter = 0;
 				fprintf(stderr, "\nAvailable events:");
 				evlist__for_each(top->evlist, top->sym_evsel)
 					fprintf(stderr, "\n\t%d %s", top->sym_evsel->idx, perf_evsel__name(top->sym_evsel));
 				prompt_integer(&counter, "Enter details event counter");
 				if (counter >= top->evlist->nr_entries) {
 					top->sym_evsel = perf_evlist__first(top->evlist);
 					fprintf(stderr, "Sorry, no such event, using %s.\n", perf_evsel__name(top->sym_evsel));
 					sleep(1);
 					break;
 				}
 				evlist__for_each(top->evlist, top->sym_evsel)
 					if (top->sym_evsel->idx == counter)
 						break;
 			} else
 				top->sym_evsel = perf_evlist__first(top->evlist);
 			break;
 		case 'f':
 			prompt_integer(&top->count_filter, "Enter display event count filter");
 			break;
 		case 'F':
 			prompt_percent(&top->sym_pcnt_filter,
 				       "Enter details display event filter (percent)");
 			break;
 		case 'K':
 			top->hide_kernel_symbols = !top->hide_kernel_symbols;
 			break;
 		case 'q':
 		case 'Q':
 			printf("exiting.\n");
 			if (top->dump_symtab)
 				perf_session__fprintf_dsos(top->session, stderr);
 			ret = false;
 			break;
 		case 's':
 			perf_top__prompt_symbol(top, "Enter details symbol");
 			break;
 		case 'S':
 			if (!top->sym_filter_entry)
 				break;
 			else {
 				struct hist_entry *syme = top->sym_filter_entry;
 				top->sym_filter_entry = NULL;
 				__zero_source_counters(syme);
 			}
 			break;
 		case 'U':
 			top->hide_user_symbols = !top->hide_user_symbols;
 			break;
 		case 'z':
 			top->zero = !top->zero;
 			break;
 		default:
 			break;
 	}
 	return ret;
 }
 static void perf_top__sort_new_samples(void *arg)
 {
 	struct perf_top *t = arg;
 	struct hists *hists;
 	perf_top__reset_sample_counters(t);
 	if (t->evlist->selected != NULL)
 		t->sym_evsel = t->evlist->selected;
 	hists = evsel__hists(t->sym_evsel);
 	if (t->zero) {
 		hists__delete_entries(hists);
 	} else {
 		hists__decay_entries(hists, t->hide_user_symbols,
 				     t->hide_kernel_symbols);
 	}
 	hists__collapse_resort(hists, NULL);
 	hists__output_resort(hists, NULL);
 }
 static void *display_thread_tui(void *arg)
 {
 	struct perf_evsel *pos;
 	struct perf_top *top = arg;
 	const char *help = "For a higher level overview, try: perf top --sort comm,dso";
 	struct hist_browser_timer hbt = {
 		.timer		= perf_top__sort_new_samples,
 		.arg		= top,
 		.refresh	= top->delay_secs,
 	};
 	perf_top__sort_new_samples(top);
 	/*
 	 * Initialize the uid_filter_str, in the future the TUI will allow
 	 * Zooming in/out UIDs. For now juse use whatever the user passed
 	 * via --uid.
 	 */
 	evlist__for_each(top->evlist, pos) {
 		struct hists *hists = evsel__hists(pos);
 		hists->uid_filter_str = top->record_opts.target.uid_str;
 	}
 	perf_evlist__tui_browse_hists(top->evlist, help, &hbt, top->min_percent,
 				      &top->session->header.env);
 	done = 1;
 	return NULL;
 }
 static void display_sig(int sig __maybe_unused)
 {
 	done = 1;
 }
 static void display_setup_sig(void)
 {
 	signal(SIGSEGV, display_sig);
 	signal(SIGFPE,  display_sig);
 	signal(SIGINT,  display_sig);
 	signal(SIGQUIT, display_sig);
 	signal(SIGTERM, display_sig);
 }
 static void *display_thread(void *arg)
 {
 	struct pollfd stdin_poll = { .fd = 0, .events = POLLIN };
 	struct termios save;
 	struct perf_top *top = arg;
 	int delay_msecs, c;
 	display_setup_sig();
 	pthread__unblock_sigwinch();
 repeat:
 	delay_msecs = top->delay_secs * 1000;
 	set_term_quiet_input(&save);
 	/* trash return*/
 	getc(stdin);
 	while (!done) {
 		perf_top__print_sym_table(top);
 		/*
 		 * Either timeout expired or we got an EINTR due to SIGWINCH,
 		 * refresh screen in both cases.
 		 */
 		switch (poll(&stdin_poll, 1, delay_msecs)) {
 		case 0:
 			continue;
 		case -1:
 			if (errno == EINTR)
 				continue;
 			/* Fall trhu */
 		default:
 			c = getc(stdin);
 			tcsetattr(0, TCSAFLUSH, &save);
 			if (perf_top__handle_keypress(top, c))
 				goto repeat;
 			done = 1;
 		}
 	}
 	tcsetattr(0, TCSAFLUSH, &save);
 	return NULL;
 }
 static int symbol_filter(struct map *map, struct symbol *sym)
 {
 	const char *name = sym->name;
 	if (!map->dso->kernel)
 		return 0;
 	/*
 	 * ppc64 uses function descriptors and appends a '.' to the
 	 * start of every instruction address. Remove it.
 	 */
 	if (name[0] == '.')
 		name++;
 	if (!strcmp(name, "_text") ||
 	    !strcmp(name, "_etext") ||
 	    !strcmp(name, "_sinittext") ||
 	    !strncmp("init_module", name, 11) ||
 	    !strncmp("cleanup_module", name, 14) ||
 	    strstr(name, "_text_start") ||
 	    strstr(name, "_text_end"))
 		return 1;
 	if (symbol__is_idle(sym))
 		sym->ignore = true;
 	return 0;
 }
 static int hist_iter__top_callback(struct hist_entry_iter *iter,
 				   struct addr_location *al, bool single,
 				   void *arg)
 {
 	struct perf_top *top = arg;
 	struct hist_entry *he = iter->he;
 	struct perf_evsel *evsel = iter->evsel;
 	if (sort__has_sym && single) {
 		u64 ip = al->addr;
 		if (al->map)
 			ip = al->map->unmap_ip(al->map, ip);
 		perf_top__record_precise_ip(top, he, evsel->idx, ip);
 	}
 	return 0;
 }
 static void perf_event__process_sample(struct perf_tool *tool,
 				       const union perf_event *event,
 				       struct perf_evsel *evsel,
 				       struct perf_sample *sample,
 				       struct machine *machine)
 {
 	struct perf_top *top = container_of(tool, struct perf_top, tool);
 	struct addr_location al;
 	int err;
 	if (!machine && perf_guest) {
 		static struct intlist *seen;
 		if (!seen)
 			seen = intlist__new(NULL);
 		if (!intlist__has_entry(seen, sample->pid)) {
 			pr_err("Can't find guest [%d]'s kernel information\n",
 				sample->pid);
 			intlist__add(seen, sample->pid);
 		}
 		return;
 	}
 	if (!machine) {
 		pr_err("%u unprocessable samples recorded.\r",
 		       top->session->stats.nr_unprocessable_samples++);
 		return;
 	}
 	if (event->header.misc & PERF_RECORD_MISC_EXACT_IP)
 		top->exact_samples++;
 	if (perf_event__preprocess_sample(event, machine, &al, sample) < 0)
 		return;
 	if (!top->kptr_restrict_warned &&
 	    symbol_conf.kptr_restrict &&
 	    al.cpumode == PERF_RECORD_MISC_KERNEL) {
 		ui__warning(
 "Kernel address maps (/proc/{kallsyms,modules}) are restricted.\n\n"
 "Check /proc/sys/kernel/kptr_restrict.\n\n"
 "Kernel%s samples will not be resolved.\n",
 			  !RB_EMPTY_ROOT(&al.map->dso->symbols[MAP__FUNCTION]) ?
 			  " modules" : "");
 		if (use_browser <= 0)
 			sleep(5);
 		top->kptr_restrict_warned = true;
 	}
 	if (al.sym == NULL) {
 		const char *msg = "Kernel samples will not be resolved.\n";
 		/*
 		 * As we do lazy loading of symtabs we only will know if the
 		 * specified vmlinux file is invalid when we actually have a
 		 * hit in kernel space and then try to load it. So if we get
 		 * here and there are _no_ symbols in the DSO backing the
 		 * kernel map, bail out.
 		 *
 		 * We may never get here, for instance, if we use -K/
 		 * --hide-kernel-symbols, even if the user specifies an
 		 * invalid --vmlinux ;-)
 		 */
 		if (!top->kptr_restrict_warned && !top->vmlinux_warned &&
 		    al.map == machine->vmlinux_maps[MAP__FUNCTION] &&
 		    RB_EMPTY_ROOT(&al.map->dso->symbols[MAP__FUNCTION])) {
 			if (symbol_conf.vmlinux_name) {
 				ui__warning("The %s file can't be used.\n%s",
 					    symbol_conf.vmlinux_name, msg);
 			} else {
 				ui__warning("A vmlinux file was not found.\n%s",
 					    msg);
 			}
 			if (use_browser <= 0)
 				sleep(5);
 			top->vmlinux_warned = true;
 		}
 	}
 	if (al.sym == NULL || !al.sym->ignore) {
 		struct hists *hists = evsel__hists(evsel);
 		struct hist_entry_iter iter = {
 			.add_entry_cb = hist_iter__top_callback,
 		};
 		if (symbol_conf.cumulate_callchain)
 			iter.ops = &hist_iter_cumulative;
 		else
 			iter.ops = &hist_iter_normal;
 		pthread_mutex_lock(&hists->lock);
 		err = hist_entry_iter__add(&iter, &al, evsel, sample,
 					   top->max_stack, top);
 		if (err < 0)
 			pr_err("Problem incrementing symbol period, skipping event\n");
 		pthread_mutex_unlock(&hists->lock);
 	}
 	return;
 }
 static void perf_top__mmap_read_idx(struct perf_top *top, int idx)
 {
 	struct perf_sample sample;
 	struct perf_evsel *evsel;
 	struct perf_session *session = top->session;
 	union perf_event *event;
 	struct machine *machine;
 	u8 origin;
 	int ret;
 	while ((event = perf_evlist__mmap_read(top->evlist, idx)) != NULL) {
 		ret = perf_evlist__parse_sample(top->evlist, event, &sample);
 		if (ret) {
 			pr_err("Can't parse sample, err = %d\n", ret);
 			goto next_event;
 		}
 		evsel = perf_evlist__id2evsel(session->evlist, sample.id);
 		assert(evsel != NULL);
 		origin = event->header.misc & PERF_RECORD_MISC_CPUMODE_MASK;
 		if (event->header.type == PERF_RECORD_SAMPLE)
 			++top->samples;
 		switch (origin) {
 		case PERF_RECORD_MISC_USER:
 			++top->us_samples;
 			if (top->hide_user_symbols)
 				goto next_event;
 			machine = &session->machines.host;
 			break;
 		case PERF_RECORD_MISC_KERNEL:
 			++top->kernel_samples;
 			if (top->hide_kernel_symbols)
 				goto next_event;
 			machine = &session->machines.host;
 			break;
 		case PERF_RECORD_MISC_GUEST_KERNEL:
 			++top->guest_kernel_samples;
 			machine = perf_session__find_machine(session,
 							     sample.pid);
 			break;
 		case PERF_RECORD_MISC_GUEST_USER:
 			++top->guest_us_samples;
 			/*
 			 * TODO: we don't process guest user from host side
 			 * except simple counting.
 			 */
 			/* Fall thru */
 		default:
 			goto next_event;
 		}
 		if (event->header.type == PERF_RECORD_SAMPLE) {
 			perf_event__process_sample(&top->tool, event, evsel,
 						   &sample, machine);
 		} else if (event->header.type < PERF_RECORD_MAX) {
 			hists__inc_nr_events(evsel__hists(evsel), event->header.type);
 			machine__process_event(machine, event, &sample);
 		} else
 			++session->stats.nr_unknown_events;
 next_event:
 		perf_evlist__mmap_consume(top->evlist, idx);
 	}
 }
 static void perf_top__mmap_read(struct perf_top *top)
 {
 	int i;
 	for (i = 0; i < top->evlist->nr_mmaps; i++)
 		perf_top__mmap_read_idx(top, i);
 }
 static int perf_top__start_counters(struct perf_top *top)
 {
 	char msg[512];
 	struct perf_evsel *counter;
 	struct perf_evlist *evlist = top->evlist;
 	struct record_opts *opts = &top->record_opts;
 	perf_evlist__config(evlist, opts);
 	evlist__for_each(evlist, counter) {
 try_again:
 		if (perf_evsel__open(counter, top->evlist->cpus,
 				     top->evlist->threads) < 0) {
 			if (perf_evsel__fallback(counter, errno, msg, sizeof(msg))) {
 				if (verbose)
 					ui__warning("%s\n", msg);
 				goto try_again;
 			}
 			perf_evsel__open_strerror(counter, &opts->target,
 						  errno, msg, sizeof(msg));
 			ui__error("%s\n", msg);
 			goto out_err;
 		}
 	}
 	if (perf_evlist__mmap(evlist, opts->mmap_pages, false) < 0) {
 		ui__error("Failed to mmap with %d (%s)\n",
 			    errno, strerror_r(errno, msg, sizeof(msg)));
 		goto out_err;
 	}
 	return 0;
 out_err:
 	return -1;
 }
 static int perf_top__setup_sample_type(struct perf_top *top __maybe_unused)
 {
 	if (!sort__has_sym) {
 		if (symbol_conf.use_callchain) {
 			ui__error("Selected -g but \"sym\" not present in --sort/-s.");
 			return -EINVAL;
 		}
 	} else if (callchain_param.mode != CHAIN_NONE) {
 		if (callchain_register_param(&callchain_param) < 0) {
 			ui__error("Can't register callchain params.\n");
 			return -EINVAL;
 		}
 	}
 	return 0;
 }
 static int __cmd_top(struct perf_top *top)
 {
 	struct record_opts *opts = &top->record_opts;
 	pthread_t thread;
 	int ret;
 	top->session = perf_session__new(NULL, false, NULL);
 	if (top->session == NULL)
 		return -1;
 	machines__set_symbol_filter(&top->session->machines, symbol_filter);
 	if (!objdump_path) {
 		ret = perf_session_env__lookup_objdump(&top->session->header.env);
 		if (ret)
 			goto out_delete;
 	}
 	ret = perf_top__setup_sample_type(top);
 	if (ret)
 		goto out_delete;
 	machine__synthesize_threads(&top->session->machines.host, &opts->target,
 				    top->evlist->threads, false);
 	ret = perf_top__start_counters(top);
 	if (ret)
 		goto out_delete;
 	top->session->evlist = top->evlist;
 	perf_session__set_id_hdr_size(top->session);
 	/*
 	 * When perf is starting the traced process, all the events (apart from
 	 * group members) have enable_on_exec=1 set, so don't spoil it by
 	 * prematurely enabling them.
 	 *
 	 * XXX 'top' still doesn't start workloads like record, trace, but should,
 	 * so leave the check here.
 	 */
         if (!target__none(&opts->target))
                 perf_evlist__enable(top->evlist);
 	/* Wait for a minimal set of events before starting the snapshot */
 	perf_evlist__poll(top->evlist, 100);
 	perf_top__mmap_read(top);
 	ret = -1;
 	if (pthread_create(&thread, NULL, (use_browser > 0 ? display_thread_tui :
 							    display_thread), top)) {
 		ui__error("Could not create display thread.\n");
 		goto out_delete;
 	}
 	if (top->realtime_prio) {
 		struct sched_param param;
 		param.sched_priority = top->realtime_prio;
 		if (sched_setscheduler(0, SCHED_FIFO, &param)) {
 			ui__error("Could not set realtime priority.\n");
 			goto out_join;
 		}
 	}
 	while (!done) {
 		u64 hits = top->samples;
 		perf_top__mmap_read(top);
 		if (hits == top->samples)
 			ret = perf_evlist__poll(top->evlist, 100);
 	}
 	ret = 0;
 out_join:
 	pthread_join(thread, NULL);
 out_delete:
 	perf_session__delete(top->session);
 	top->session = NULL;
 	return ret;
 }
 static int
 callchain_opt(const struct option *opt, const char *arg, int unset)
 {
 	symbol_conf.use_callchain = true;
 	return record_callchain_opt(opt, arg, unset);
 }
 static int
 parse_callchain_opt(const struct option *opt, const char *arg, int unset)
 {
 	symbol_conf.use_callchain = true;
 	return record_parse_callchain_opt(opt, arg, unset);
 }
 static int perf_top_config(const char *var, const char *value, void *cb)
 {
 	if (!strcmp(var, "top.call-graph"))
 		var = "call-graph.record-mode"; /* fall-through */
 	if (!strcmp(var, "top.children")) {
 		symbol_conf.cumulate_callchain = perf_config_bool(var, value);
 		return 0;
 	}
 	return perf_default_config(var, value, cb);
 }
 static int
 parse_percent_limit(const struct option *opt, const char *arg,
 		    int unset __maybe_unused)
 {
 	struct perf_top *top = opt->value;
 	top->min_percent = strtof(arg, NULL);
 	return 0;
 }
 int cmd_top(int argc, const char **argv, const char *prefix __maybe_unused)
 {
 	char errbuf[BUFSIZ];
 	struct perf_top top = {
 		.count_filter	     = 5,
 		.delay_secs	     = 2,
 		.record_opts = {
 			.mmap_pages	= UINT_MAX,
 			.user_freq	= UINT_MAX,
 			.user_interval	= ULLONG_MAX,
 			.freq		= 4000, /* 4 KHz */
 			.target		= {
 				.uses_mmap   = true,
 			},
 		},
 		.max_stack	     = PERF_MAX_STACK_DEPTH,
 		.sym_pcnt_filter     = 5,
 	};
 	struct record_opts *opts = &top.record_opts;
 	struct target *target = &opts->target;
 	const struct option options[] = {
 	OPT_CALLBACK('e', "event", &top.evlist, "event",
 		     "event selector. use 'perf list' to list available events",
 		     parse_events_option),
 	OPT_U64('c', "count", &opts->user_interval, "event period to sample"),
 	OPT_STRING('p', "pid", &target->pid, "pid",
 		    "profile events on existing process id"),
 	OPT_STRING('t', "tid", &target->tid, "tid",
 		    "profile events on existing thread id"),
 	OPT_BOOLEAN('a', "all-cpus", &target->system_wide,
 			    "system-wide collection from all CPUs"),
 	OPT_STRING('C', "cpu", &target->cpu_list, "cpu",
 		    "list of cpus to monitor"),
 	OPT_STRING('k', "vmlinux", &symbol_conf.vmlinux_name,
 		   "file", "vmlinux pathname"),
 	OPT_BOOLEAN(0, "ignore-vmlinux", &symbol_conf.ignore_vmlinux,
 		    "don't load vmlinux even if found"),
 	OPT_BOOLEAN('K', "hide_kernel_symbols", &top.hide_kernel_symbols,
 		    "hide kernel symbols"),
 	OPT_CALLBACK('m', "mmap-pages", &opts->mmap_pages, "pages",
 		     "number of mmap data pages",
 		     perf_evlist__parse_mmap_pages),
 	OPT_INTEGER('r', "realtime", &top.realtime_prio,
 		    "collect data with this RT SCHED_FIFO priority"),
 	OPT_INTEGER('d', "delay", &top.delay_secs,
 		    "number of seconds to delay between refreshes"),
 	OPT_BOOLEAN('D', "dump-symtab", &top.dump_symtab,
 			    "dump the symbol table used for profiling"),
 	OPT_INTEGER('f', "count-filter", &top.count_filter,
 		    "only display functions with more events than this"),
 	OPT_BOOLEAN(0, "group", &opts->group,
 			    "put the counters into a counter group"),
 	OPT_BOOLEAN('i', "no-inherit", &opts->no_inherit,
 		    "child tasks do not inherit counters"),
 	OPT_STRING(0, "sym-annotate", &top.sym_filter, "symbol name",
 		    "symbol to annotate"),
 	OPT_BOOLEAN('z', "zero", &top.zero, "zero history across updates"),
 	OPT_UINTEGER('F', "freq", &opts->user_freq, "profile at this frequency"),
 	OPT_INTEGER('E', "entries", &top.print_entries,
 		    "display this many functions"),
 	OPT_BOOLEAN('U', "hide_user_symbols", &top.hide_user_symbols,
 		    "hide user symbols"),
 	OPT_BOOLEAN(0, "tui", &top.use_tui, "Use the TUI interface"),
 	OPT_BOOLEAN(0, "stdio", &top.use_stdio, "Use the stdio interface"),
 	OPT_INCR('v', "verbose", &verbose,
 		    "be more verbose (show counter open errors, etc)"),
 	OPT_STRING('s', "sort", &sort_order, "key[,key2...]",
 		   "sort by key(s): pid, comm, dso, symbol, parent, cpu, srcline, ..."
 		   " Please refer the man page for the complete list."),
 	OPT_STRING(0, "fields", &field_order, "key[,keys...]",
 		   "output field(s): overhead, period, sample plus all of sort keys"),
 	OPT_BOOLEAN('n', "show-nr-samples", &symbol_conf.show_nr_samples,
 		    "Show a column with the number of samples"),
 	OPT_CALLBACK_NOOPT('g', NULL, &top.record_opts,
 			   NULL, "enables call-graph recording",
 			   &callchain_opt),
 	OPT_CALLBACK(0, "call-graph", &top.record_opts,
 		     "mode[,dump_size]", record_callchain_help,
 		     &parse_callchain_opt),
 	OPT_BOOLEAN(0, "children", &symbol_conf.cumulate_callchain,
 		    "Accumulate callchains of children and show total overhead as well"),
 	OPT_INTEGER(0, "max-stack", &top.max_stack,
 		    "Set the maximum stack depth when parsing the callchain. "
 		    "Default: " __stringify(PERF_MAX_STACK_DEPTH)),
 	OPT_CALLBACK(0, "ignore-callees", NULL, "regex",
 		   "ignore callees of these functions in call graphs",
 		   report_parse_ignore_callees_opt),
 	OPT_BOOLEAN(0, "show-total-period", &symbol_conf.show_total_period,
 		    "Show a column with the sum of periods"),
 	OPT_STRING(0, "dsos", &symbol_conf.dso_list_str, "dso[,dso...]",
 		   "only consider symbols in these dsos"),
 	OPT_STRING(0, "comms", &symbol_conf.comm_list_str, "comm[,comm...]",
 		   "only consider symbols in these comms"),
 	OPT_STRING(0, "symbols", &symbol_conf.sym_list_str, "symbol[,symbol...]",
 		   "only consider these symbols"),
 	OPT_BOOLEAN(0, "source", &symbol_conf.annotate_src,
 		    "Interleave source code with assembly code (default)"),
 	OPT_BOOLEAN(0, "asm-raw", &symbol_conf.annotate_asm_raw,
 		    "Display raw encoding of assembly instructions (default)"),
 	OPT_BOOLEAN(0, "demangle-kernel", &symbol_conf.demangle_kernel,
 		    "Enable kernel symbol demangling"),
 	OPT_STRING(0, "objdump", &objdump_path, "path",
 		    "objdump binary to use for disassembly and annotations"),
 	OPT_STRING('M', "disassembler-style", &disassembler_style, "disassembler style",
 		   "Specify disassembler style (e.g. -M intel for intel syntax)"),
 	OPT_STRING('u', "uid", &target->uid_str, "user", "user to profile"),
 	OPT_CALLBACK(0, "percent-limit", &top, "percent",
 		     "Don't show entries under that percent", parse_percent_limit),
 	OPT_CALLBACK(0, "percentage", NULL, "relative|absolute",
 		     "How to display percentage of filtered entries", parse_filter_percentage),
 	OPT_STRING('w', "column-widths", &symbol_conf.col_width_list_str,
 		   "width[,width...]",
 		   "don't try to adjust column width, use these fixed values"),
 	OPT_END()
 	};
 	const char * const top_usage[] = {
 		"perf top [<options>]",
 		NULL
 	};
 	int status = hists__init();
 	if (status < 0)
 		return status;
 	top.evlist = perf_evlist__new();
 	if (top.evlist == NULL)
 		return -ENOMEM;
 	perf_config(perf_top_config, &top);
 	argc = parse_options(argc, argv, options, top_usage, 0);
 	if (argc)
 		usage_with_options(top_usage, options);
 	sort__mode = SORT_MODE__TOP;
 	/* display thread wants entries to be collapsed in a different tree */
 	sort__need_collapse = 1;
 	if (setup_sorting() < 0) {
 		if (sort_order)
 			parse_options_usage(top_usage, options, "s", 1);
 		if (field_order)
 			parse_options_usage(sort_order ? NULL : top_usage,
 					    options, "fields", 0);
 		goto out_delete_evlist;
 	}
 	if (top.use_stdio)
 		use_browser = 0;
 	else if (top.use_tui)
 		use_browser = 1;
 	setup_browser(false);
 	status = target__validate(target);
 	if (status) {
 		target__strerror(target, status, errbuf, BUFSIZ);
 		ui__warning("%s\n", errbuf);
 	}
 	status = target__parse_uid(target);
 	if (status) {
 		int saved_errno = errno;
 		target__strerror(target, status, errbuf, BUFSIZ);
 		ui__error("%s\n", errbuf);
 		status = -saved_errno;
 		goto out_delete_evlist;
 	}
 	if (target__none(target))
 		target->system_wide = true;
 	if (perf_evlist__create_maps(top.evlist, target) < 0)
 		usage_with_options(top_usage, options);
 	if (!top.evlist->nr_entries &&
 	    perf_evlist__add_default(top.evlist) < 0) {
 		ui__error("Not enough memory for event selector list\n");
 		goto out_delete_evlist;
 	}
 	symbol_conf.nr_events = top.evlist->nr_entries;
 	if (top.delay_secs < 1)
 		top.delay_secs = 1;
 	if (record_opts__config(opts)) {
 		status = -EINVAL;
 		goto out_delete_evlist;
 	}
 	top.sym_evsel = perf_evlist__first(top.evlist);
 	if (!symbol_conf.use_callchain) {
 		symbol_conf.cumulate_callchain = false;
 		perf_hpp__cancel_cumulate();
 	}
 	symbol_conf.priv_size = sizeof(struct annotation);
 	symbol_conf.try_vmlinux_path = (symbol_conf.vmlinux_name == NULL);
 	if (symbol__init(NULL) < 0)
 		return -1;
 	sort__setup_elide(stdout);
 	get_term_dimensions(&top.winsize);
 	if (top.print_entries == 0) {
 		struct sigaction act = {
 			.sa_sigaction = perf_top__sig_winch,
 			.sa_flags     = SA_SIGINFO,
 		};
 		perf_top__update_print_entries(&top);
 		sigaction(SIGWINCH, &act, NULL);
 	}
 	status = __cmd_top(&top);
 out_delete_evlist:
 	perf_evlist__delete(top.evlist);
 	return status;
 }

tools/perf/config/Makefile

Diff comments View file @ 59b2858

1		1
2	ifeq ($(src-perf),)	2	ifeq ($(src-perf),)
3	src-perf := $(srctree)/tools/perf	3	src-perf := $(srctree)/tools/perf
4	endif	4	endif
5		5
6	ifeq ($(obj-perf),)	6	ifeq ($(obj-perf),)
7	obj-perf := $(OUTPUT)	7	obj-perf := $(OUTPUT)
8	endif	8	endif
9		9
10	ifneq ($(obj-perf),)	10	ifneq ($(obj-perf),)
11	obj-perf := $(abspath $(obj-perf))/	11	obj-perf := $(abspath $(obj-perf))/
12	endif	12	endif
13		13
14	LIB_INCLUDE := $(srctree)/tools/lib/	14	LIB_INCLUDE := $(srctree)/tools/lib/
15	CFLAGS := $(EXTRA_CFLAGS) $(EXTRA_WARNINGS)	15	CFLAGS := $(EXTRA_CFLAGS) $(EXTRA_WARNINGS)
16		16
17	include $(src-perf)/config/Makefile.arch	17	include $(src-perf)/config/Makefile.arch
18		18
19	NO_PERF_REGS := 1	19	NO_PERF_REGS := 1
20		20
21	# Additional ARCH settings for x86	21	# Additional ARCH settings for x86
22	ifeq ($(ARCH),x86)	22	ifeq ($(ARCH),x86)
23	ifeq (${IS_X86_64}, 1)	23	ifeq (${IS_64_BIT}, 1)
24	CFLAGS += -DHAVE_ARCH_X86_64_SUPPORT	24	CFLAGS += -DHAVE_ARCH_X86_64_SUPPORT
25	ARCH_INCLUDE = ../../arch/x86/lib/memcpy_64.S ../../arch/x86/lib/memset_64.S	25	ARCH_INCLUDE = ../../arch/x86/lib/memcpy_64.S ../../arch/x86/lib/memset_64.S
26	LIBUNWIND_LIBS = -lunwind -lunwind-x86_64	26	LIBUNWIND_LIBS = -lunwind -lunwind-x86_64
27	else	27	else
28	LIBUNWIND_LIBS = -lunwind -lunwind-x86	28	LIBUNWIND_LIBS = -lunwind -lunwind-x86
29	endif	29	endif
30	NO_PERF_REGS := 0	30	NO_PERF_REGS := 0
31	endif	31	endif
32		32
33	ifeq ($(ARCH),arm)	33	ifeq ($(ARCH),arm)
34	NO_PERF_REGS := 0	34	NO_PERF_REGS := 0
35	LIBUNWIND_LIBS = -lunwind -lunwind-arm	35	LIBUNWIND_LIBS = -lunwind -lunwind-arm
36	endif	36	endif
37		37
38	ifeq ($(ARCH),arm64)	38	ifeq ($(ARCH),arm64)
39	NO_PERF_REGS := 0	39	NO_PERF_REGS := 0
40	LIBUNWIND_LIBS = -lunwind -lunwind-aarch64	40	LIBUNWIND_LIBS = -lunwind -lunwind-aarch64
41	endif	41	endif
42		42
43	# So far there's only x86 and arm libdw unwind support merged in perf.	43	# So far there's only x86 and arm libdw unwind support merged in perf.
44	# Disable it on all other architectures in case libdw unwind	44	# Disable it on all other architectures in case libdw unwind
45	# support is detected in system. Add supported architectures	45	# support is detected in system. Add supported architectures
46	# to the check.	46	# to the check.
47	ifneq ($(ARCH),$(filter $(ARCH),x86 arm))	47	ifneq ($(ARCH),$(filter $(ARCH),x86 arm))
48	NO_LIBDW_DWARF_UNWIND := 1	48	NO_LIBDW_DWARF_UNWIND := 1
49	endif	49	endif
50		50
51	ifeq ($(LIBUNWIND_LIBS),)	51	ifeq ($(LIBUNWIND_LIBS),)
52	NO_LIBUNWIND := 1	52	NO_LIBUNWIND := 1
53	else	53	else
54	#	54	#
55	# For linking with debug library, run like:	55	# For linking with debug library, run like:
56	#	56	#
57	# make DEBUG=1 LIBUNWIND_DIR=/opt/libunwind/	57	# make DEBUG=1 LIBUNWIND_DIR=/opt/libunwind/
58	#	58	#
59	ifdef LIBUNWIND_DIR	59	ifdef LIBUNWIND_DIR
60	LIBUNWIND_CFLAGS = -I$(LIBUNWIND_DIR)/include	60	LIBUNWIND_CFLAGS = -I$(LIBUNWIND_DIR)/include
61	LIBUNWIND_LDFLAGS = -L$(LIBUNWIND_DIR)/lib	61	LIBUNWIND_LDFLAGS = -L$(LIBUNWIND_DIR)/lib
62	endif	62	endif
63	LIBUNWIND_LDFLAGS += $(LIBUNWIND_LIBS)	63	LIBUNWIND_LDFLAGS += $(LIBUNWIND_LIBS)
64		64
65	# Set per-feature check compilation flags	65	# Set per-feature check compilation flags
66	FEATURE_CHECK_CFLAGS-libunwind = $(LIBUNWIND_CFLAGS)	66	FEATURE_CHECK_CFLAGS-libunwind = $(LIBUNWIND_CFLAGS)
67	FEATURE_CHECK_LDFLAGS-libunwind = $(LIBUNWIND_LDFLAGS)	67	FEATURE_CHECK_LDFLAGS-libunwind = $(LIBUNWIND_LDFLAGS)
68	FEATURE_CHECK_CFLAGS-libunwind-debug-frame = $(LIBUNWIND_CFLAGS)	68	FEATURE_CHECK_CFLAGS-libunwind-debug-frame = $(LIBUNWIND_CFLAGS)
69	FEATURE_CHECK_LDFLAGS-libunwind-debug-frame = $(LIBUNWIND_LDFLAGS)	69	FEATURE_CHECK_LDFLAGS-libunwind-debug-frame = $(LIBUNWIND_LDFLAGS)
70	endif	70	endif
71		71
72	ifeq ($(NO_PERF_REGS),0)	72	ifeq ($(NO_PERF_REGS),0)
73	CFLAGS += -DHAVE_PERF_REGS_SUPPORT	73	CFLAGS += -DHAVE_PERF_REGS_SUPPORT
74	endif	74	endif
75		75
76	ifndef NO_LIBELF	76	ifndef NO_LIBELF
77	# for linking with debug library, run like:	77	# for linking with debug library, run like:
78	# make DEBUG=1 LIBDW_DIR=/opt/libdw/	78	# make DEBUG=1 LIBDW_DIR=/opt/libdw/
79	ifdef LIBDW_DIR	79	ifdef LIBDW_DIR
80	LIBDW_CFLAGS := -I$(LIBDW_DIR)/include	80	LIBDW_CFLAGS := -I$(LIBDW_DIR)/include
81	LIBDW_LDFLAGS := -L$(LIBDW_DIR)/lib	81	LIBDW_LDFLAGS := -L$(LIBDW_DIR)/lib
82	endif	82	endif
83	FEATURE_CHECK_CFLAGS-libdw-dwarf-unwind := $(LIBDW_CFLAGS)	83	FEATURE_CHECK_CFLAGS-libdw-dwarf-unwind := $(LIBDW_CFLAGS)
84	FEATURE_CHECK_LDFLAGS-libdw-dwarf-unwind := $(LIBDW_LDFLAGS) -ldw	84	FEATURE_CHECK_LDFLAGS-libdw-dwarf-unwind := $(LIBDW_LDFLAGS) -ldw
85	endif	85	endif
86		86
87	# include ARCH specific config	87	# include ARCH specific config
88	-include $(src-perf)/arch/$(ARCH)/Makefile	88	-include $(src-perf)/arch/$(ARCH)/Makefile
89		89
90	include $(src-perf)/config/utilities.mak	90	include $(src-perf)/config/utilities.mak
91		91
92	ifeq ($(call get-executable,$(FLEX)),)	92	ifeq ($(call get-executable,$(FLEX)),)
93	dummy := $(error Error: $(FLEX) is missing on this system, please install it)	93	dummy := $(error Error: $(FLEX) is missing on this system, please install it)
94	endif	94	endif
95		95
96	ifeq ($(call get-executable,$(BISON)),)	96	ifeq ($(call get-executable,$(BISON)),)
97	dummy := $(error Error: $(BISON) is missing on this system, please install it)	97	dummy := $(error Error: $(BISON) is missing on this system, please install it)
98	endif	98	endif
99		99
100	# Treat warnings as errors unless directed not to	100	# Treat warnings as errors unless directed not to
101	ifneq ($(WERROR),0)	101	ifneq ($(WERROR),0)
102	CFLAGS += -Werror	102	CFLAGS += -Werror
103	endif	103	endif
104		104
105	ifndef DEBUG	105	ifndef DEBUG
106	DEBUG := 0	106	DEBUG := 0
107	endif	107	endif
108		108
109	ifeq ($(DEBUG),0)	109	ifeq ($(DEBUG),0)
110	CFLAGS += -O6	110	CFLAGS += -O6
111	endif	111	endif
112		112
113	ifdef PARSER_DEBUG	113	ifdef PARSER_DEBUG
114	PARSER_DEBUG_BISON := -t	114	PARSER_DEBUG_BISON := -t
115	PARSER_DEBUG_FLEX := -d	115	PARSER_DEBUG_FLEX := -d
116	CFLAGS += -DPARSER_DEBUG	116	CFLAGS += -DPARSER_DEBUG
117	endif	117	endif
118		118
119	ifndef NO_LIBPYTHON	119	ifndef NO_LIBPYTHON
120	# Try different combinations to accommodate systems that only have	120	# Try different combinations to accommodate systems that only have
121	# python[2][-config] in weird combinations but always preferring	121	# python[2][-config] in weird combinations but always preferring
122	# python2 and python2-config as per pep-0394. If we catch a	122	# python2 and python2-config as per pep-0394. If we catch a
123	# python[-config] in version 3, the version check will kill it.	123	# python[-config] in version 3, the version check will kill it.
124	PYTHON2 := $(if $(call get-executable,python2),python2,python)	124	PYTHON2 := $(if $(call get-executable,python2),python2,python)
125	override PYTHON := $(call get-executable-or-default,PYTHON,$(PYTHON2))	125	override PYTHON := $(call get-executable-or-default,PYTHON,$(PYTHON2))
126	PYTHON2_CONFIG := \	126	PYTHON2_CONFIG := \
127	$(if $(call get-executable,$(PYTHON)-config),$(PYTHON)-config,python-config)	127	$(if $(call get-executable,$(PYTHON)-config),$(PYTHON)-config,python-config)
128	override PYTHON_CONFIG := \	128	override PYTHON_CONFIG := \
129	$(call get-executable-or-default,PYTHON_CONFIG,$(PYTHON2_CONFIG))	129	$(call get-executable-or-default,PYTHON_CONFIG,$(PYTHON2_CONFIG))
130		130
131	PYTHON_CONFIG_SQ := $(call shell-sq,$(PYTHON_CONFIG))	131	PYTHON_CONFIG_SQ := $(call shell-sq,$(PYTHON_CONFIG))
132		132
133	PYTHON_EMBED_LDOPTS := $(shell $(PYTHON_CONFIG_SQ) --ldflags 2>/dev/null)	133	PYTHON_EMBED_LDOPTS := $(shell $(PYTHON_CONFIG_SQ) --ldflags 2>/dev/null)
134	PYTHON_EMBED_CCOPTS := $(shell $(PYTHON_CONFIG_SQ) --cflags 2>/dev/null)	134	PYTHON_EMBED_CCOPTS := $(shell $(PYTHON_CONFIG_SQ) --cflags 2>/dev/null)
135		135
136	FEATURE_CHECK_CFLAGS-libpython := $(PYTHON_EMBED_CCOPTS)	136	FEATURE_CHECK_CFLAGS-libpython := $(PYTHON_EMBED_CCOPTS)
137	FEATURE_CHECK_LDFLAGS-libpython := $(PYTHON_EMBED_LDOPTS)	137	FEATURE_CHECK_LDFLAGS-libpython := $(PYTHON_EMBED_LDOPTS)
138	FEATURE_CHECK_CFLAGS-libpython-version := $(PYTHON_EMBED_CCOPTS)	138	FEATURE_CHECK_CFLAGS-libpython-version := $(PYTHON_EMBED_CCOPTS)
139	FEATURE_CHECK_LDFLAGS-libpython-version := $(PYTHON_EMBED_LDOPTS)	139	FEATURE_CHECK_LDFLAGS-libpython-version := $(PYTHON_EMBED_LDOPTS)
140	endif	140	endif
141		141
142	CFLAGS += -fno-omit-frame-pointer	142	CFLAGS += -fno-omit-frame-pointer
143	CFLAGS += -ggdb3	143	CFLAGS += -ggdb3
144	CFLAGS += -funwind-tables	144	CFLAGS += -funwind-tables
145	CFLAGS += -Wall	145	CFLAGS += -Wall
146	CFLAGS += -Wextra	146	CFLAGS += -Wextra
147	CFLAGS += -std=gnu99	147	CFLAGS += -std=gnu99
148		148
149	# Enforce a non-executable stack, as we may regress (again) in the future by	149	# Enforce a non-executable stack, as we may regress (again) in the future by
150	# adding assembler files missing the .GNU-stack linker note.	150	# adding assembler files missing the .GNU-stack linker note.
151	LDFLAGS += -Wl,-z,noexecstack	151	LDFLAGS += -Wl,-z,noexecstack
152		152
153	EXTLIBS = -lpthread -lrt -lm -ldl	153	EXTLIBS = -lpthread -lrt -lm -ldl
154		154
155	ifneq ($(OUTPUT),)	155	ifneq ($(OUTPUT),)
156	OUTPUT_FEATURES = $(OUTPUT)config/feature-checks/	156	OUTPUT_FEATURES = $(OUTPUT)config/feature-checks/
157	$(shell mkdir -p $(OUTPUT_FEATURES))	157	$(shell mkdir -p $(OUTPUT_FEATURES))
158	endif	158	endif
159		159
160	feature_check = $(eval $(feature_check_code))	160	feature_check = $(eval $(feature_check_code))
161	define feature_check_code	161	define feature_check_code
162	feature-$(1) := $(shell $(MAKE) OUTPUT=$(OUTPUT_FEATURES) CFLAGS="$(EXTRA_CFLAGS) $(FEATURE_CHECK_CFLAGS-$(1))" LDFLAGS="$(LDFLAGS) $(FEATURE_CHECK_LDFLAGS-$(1))" -C config/feature-checks test-$1.bin >/dev/null 2>/dev/null && echo 1 \|\| echo 0)	162	feature-$(1) := $(shell $(MAKE) OUTPUT=$(OUTPUT_FEATURES) CFLAGS="$(EXTRA_CFLAGS) $(FEATURE_CHECK_CFLAGS-$(1))" LDFLAGS="$(LDFLAGS) $(FEATURE_CHECK_LDFLAGS-$(1))" -C config/feature-checks test-$1.bin >/dev/null 2>/dev/null && echo 1 \|\| echo 0)
163	endef	163	endef
164		164
165	feature_set = $(eval $(feature_set_code))	165	feature_set = $(eval $(feature_set_code))
166	define feature_set_code	166	define feature_set_code
167	feature-$(1) := 1	167	feature-$(1) := 1
168	endef	168	endef
169		169
170	#	170	#
171	# Build the feature check binaries in parallel, ignore errors, ignore return value and suppress output:	171	# Build the feature check binaries in parallel, ignore errors, ignore return value and suppress output:
172	#	172	#
173		173
174	#	174	#
175	# Note that this is not a complete list of all feature tests, just	175	# Note that this is not a complete list of all feature tests, just
176	# those that are typically built on a fully configured system.	176	# those that are typically built on a fully configured system.
177	#	177	#
178	# [ Feature tests not mentioned here have to be built explicitly in	178	# [ Feature tests not mentioned here have to be built explicitly in
179	# the rule that uses them - an example for that is the 'bionic'	179	# the rule that uses them - an example for that is the 'bionic'
180	# feature check. ]	180	# feature check. ]
181	#	181	#
182	CORE_FEATURE_TESTS = \	182	CORE_FEATURE_TESTS = \
183	backtrace \	183	backtrace \
184	dwarf \	184	dwarf \
185	fortify-source \	185	fortify-source \
186	sync-compare-and-swap \	186	sync-compare-and-swap \
187	glibc \	187	glibc \
188	gtk2 \	188	gtk2 \
189	gtk2-infobar \	189	gtk2-infobar \
190	libaudit \	190	libaudit \
191	libbfd \	191	libbfd \
192	libelf \	192	libelf \
193	libelf-getphdrnum \	193	libelf-getphdrnum \
194	libelf-mmap \	194	libelf-mmap \
195	libnuma \	195	libnuma \
196	libperl \	196	libperl \
197	libpython \	197	libpython \
198	libpython-version \	198	libpython-version \
199	libslang \	199	libslang \
200	libunwind \	200	libunwind \
201	stackprotector-all \	201	stackprotector-all \
202	timerfd \	202	timerfd \
203	libdw-dwarf-unwind \	203	libdw-dwarf-unwind \
204	zlib	204	zlib
205		205
206	LIB_FEATURE_TESTS = \	206	LIB_FEATURE_TESTS = \
207	dwarf \	207	dwarf \
208	glibc \	208	glibc \
209	gtk2 \	209	gtk2 \
210	libaudit \	210	libaudit \
211	libbfd \	211	libbfd \
212	libelf \	212	libelf \
213	libnuma \	213	libnuma \
214	libperl \	214	libperl \
215	libpython \	215	libpython \
216	libslang \	216	libslang \
217	libunwind \	217	libunwind \
218	libdw-dwarf-unwind \	218	libdw-dwarf-unwind \
219	zlib	219	zlib
220		220
221	VF_FEATURE_TESTS = \	221	VF_FEATURE_TESTS = \
222	backtrace \	222	backtrace \
223	fortify-source \	223	fortify-source \
224	sync-compare-and-swap \	224	sync-compare-and-swap \
225	gtk2-infobar \	225	gtk2-infobar \
226	libelf-getphdrnum \	226	libelf-getphdrnum \
227	libelf-mmap \	227	libelf-mmap \
228	libpython-version \	228	libpython-version \
229	stackprotector-all \	229	stackprotector-all \
230	timerfd \	230	timerfd \
231	libunwind-debug-frame \	231	libunwind-debug-frame \
232	bionic \	232	bionic \
233	liberty \	233	liberty \
234	liberty-z \	234	liberty-z \
235	cplus-demangle \	235	cplus-demangle \
236	compile-32 \	236	compile-32 \
237	compile-x32	237	compile-x32
238		238
239	# Set FEATURE_CHECK_(C\|LD)FLAGS-all for all CORE_FEATURE_TESTS features.	239	# Set FEATURE_CHECK_(C\|LD)FLAGS-all for all CORE_FEATURE_TESTS features.
240	# If in the future we need per-feature checks/flags for features not	240	# If in the future we need per-feature checks/flags for features not
241	# mentioned in this list we need to refactor this ;-).	241	# mentioned in this list we need to refactor this ;-).
242	set_test_all_flags = $(eval $(set_test_all_flags_code))	242	set_test_all_flags = $(eval $(set_test_all_flags_code))
243	define set_test_all_flags_code	243	define set_test_all_flags_code
244	FEATURE_CHECK_CFLAGS-all += $(FEATURE_CHECK_CFLAGS-$(1))	244	FEATURE_CHECK_CFLAGS-all += $(FEATURE_CHECK_CFLAGS-$(1))
245	FEATURE_CHECK_LDFLAGS-all += $(FEATURE_CHECK_LDFLAGS-$(1))	245	FEATURE_CHECK_LDFLAGS-all += $(FEATURE_CHECK_LDFLAGS-$(1))
246	endef	246	endef
247		247
248	$(foreach feat,$(CORE_FEATURE_TESTS),$(call set_test_all_flags,$(feat)))	248	$(foreach feat,$(CORE_FEATURE_TESTS),$(call set_test_all_flags,$(feat)))
249		249
250	#	250	#
251	# Special fast-path for the 'all features are available' case:	251	# Special fast-path for the 'all features are available' case:
252	#	252	#
253	$(call feature_check,all,$(MSG))	253	$(call feature_check,all,$(MSG))
254		254
255	#	255	#
256	# Just in case the build freshly failed, make sure we print the	256	# Just in case the build freshly failed, make sure we print the
257	# feature matrix:	257	# feature matrix:
258	#	258	#
259	ifeq ($(feature-all), 1)	259	ifeq ($(feature-all), 1)
260	#	260	#
261	# test-all.c passed - just set all the core feature flags to 1:	261	# test-all.c passed - just set all the core feature flags to 1:
262	#	262	#
263	$(foreach feat,$(CORE_FEATURE_TESTS),$(call feature_set,$(feat)))	263	$(foreach feat,$(CORE_FEATURE_TESTS),$(call feature_set,$(feat)))
264	else	264	else
265	$(shell $(MAKE) OUTPUT=$(OUTPUT_FEATURES) CFLAGS="$(EXTRA_CFLAGS)" LDFLAGS=$(LDFLAGS) -i -j -C config/feature-checks $(addsuffix .bin,$(CORE_FEATURE_TESTS)) >/dev/null 2>&1)	265	$(shell $(MAKE) OUTPUT=$(OUTPUT_FEATURES) CFLAGS="$(EXTRA_CFLAGS)" LDFLAGS=$(LDFLAGS) -i -j -C config/feature-checks $(addsuffix .bin,$(CORE_FEATURE_TESTS)) >/dev/null 2>&1)
266	$(foreach feat,$(CORE_FEATURE_TESTS),$(call feature_check,$(feat)))	266	$(foreach feat,$(CORE_FEATURE_TESTS),$(call feature_check,$(feat)))
267	endif	267	endif
268		268
269	ifeq ($(feature-stackprotector-all), 1)	269	ifeq ($(feature-stackprotector-all), 1)
270	CFLAGS += -fstack-protector-all	270	CFLAGS += -fstack-protector-all
271	endif	271	endif
272		272
273	ifeq ($(DEBUG),0)	273	ifeq ($(DEBUG),0)
274	ifeq ($(feature-fortify-source), 1)	274	ifeq ($(feature-fortify-source), 1)
275	CFLAGS += -D_FORTIFY_SOURCE=2	275	CFLAGS += -D_FORTIFY_SOURCE=2
276	endif	276	endif
277	endif	277	endif
278		278
279	CFLAGS += -I$(src-perf)/util/include	279	CFLAGS += -I$(src-perf)/util/include
280	CFLAGS += -I$(src-perf)/arch/$(ARCH)/include	280	CFLAGS += -I$(src-perf)/arch/$(ARCH)/include
281	CFLAGS += -I$(srctree)/tools/include/	281	CFLAGS += -I$(srctree)/tools/include/
282	CFLAGS += -I$(srctree)/arch/$(ARCH)/include/uapi	282	CFLAGS += -I$(srctree)/arch/$(ARCH)/include/uapi
283	CFLAGS += -I$(srctree)/arch/$(ARCH)/include	283	CFLAGS += -I$(srctree)/arch/$(ARCH)/include
284	CFLAGS += -I$(srctree)/include/uapi	284	CFLAGS += -I$(srctree)/include/uapi
285	CFLAGS += -I$(srctree)/include	285	CFLAGS += -I$(srctree)/include
286		286
287	# $(obj-perf) for generated common-cmds.h	287	# $(obj-perf) for generated common-cmds.h
288	# $(obj-perf)/util for generated bison/flex headers	288	# $(obj-perf)/util for generated bison/flex headers
289	ifneq ($(OUTPUT),)	289	ifneq ($(OUTPUT),)
290	CFLAGS += -I$(obj-perf)/util	290	CFLAGS += -I$(obj-perf)/util
291	CFLAGS += -I$(obj-perf)	291	CFLAGS += -I$(obj-perf)
292	endif	292	endif
293		293
294	CFLAGS += -I$(src-perf)/util	294	CFLAGS += -I$(src-perf)/util
295	CFLAGS += -I$(src-perf)	295	CFLAGS += -I$(src-perf)
296	CFLAGS += -I$(LIB_INCLUDE)	296	CFLAGS += -I$(LIB_INCLUDE)
297		297
298	CFLAGS += -D_LARGEFILE64_SOURCE -D_FILE_OFFSET_BITS=64 -D_GNU_SOURCE	298	CFLAGS += -D_LARGEFILE64_SOURCE -D_FILE_OFFSET_BITS=64 -D_GNU_SOURCE
299		299
300	ifeq ($(feature-sync-compare-and-swap), 1)	300	ifeq ($(feature-sync-compare-and-swap), 1)
301	CFLAGS += -DHAVE_SYNC_COMPARE_AND_SWAP_SUPPORT	301	CFLAGS += -DHAVE_SYNC_COMPARE_AND_SWAP_SUPPORT
302	endif	302	endif
303		303
304	ifndef NO_BIONIC	304	ifndef NO_BIONIC
305	$(call feature_check,bionic)	305	$(call feature_check,bionic)
306	ifeq ($(feature-bionic), 1)	306	ifeq ($(feature-bionic), 1)
307	BIONIC := 1	307	BIONIC := 1
308	EXTLIBS := $(filter-out -lrt,$(EXTLIBS))	308	EXTLIBS := $(filter-out -lrt,$(EXTLIBS))
309	EXTLIBS := $(filter-out -lpthread,$(EXTLIBS))	309	EXTLIBS := $(filter-out -lpthread,$(EXTLIBS))
310	endif	310	endif
311	endif	311	endif
312		312
313	ifdef NO_LIBELF	313	ifdef NO_LIBELF
314	NO_DWARF := 1	314	NO_DWARF := 1
315	NO_DEMANGLE := 1	315	NO_DEMANGLE := 1
316	NO_LIBUNWIND := 1	316	NO_LIBUNWIND := 1
317	NO_LIBDW_DWARF_UNWIND := 1	317	NO_LIBDW_DWARF_UNWIND := 1
318	else	318	else
319	ifeq ($(feature-libelf), 0)	319	ifeq ($(feature-libelf), 0)
320	ifeq ($(feature-glibc), 1)	320	ifeq ($(feature-glibc), 1)
321	LIBC_SUPPORT := 1	321	LIBC_SUPPORT := 1
322	endif	322	endif
323	ifeq ($(BIONIC),1)	323	ifeq ($(BIONIC),1)
324	LIBC_SUPPORT := 1	324	LIBC_SUPPORT := 1
325	endif	325	endif
326	ifeq ($(LIBC_SUPPORT),1)	326	ifeq ($(LIBC_SUPPORT),1)
327	msg := $(warning No libelf found, disables 'probe' tool, please install elfutils-libelf-devel/libelf-dev);	327	msg := $(warning No libelf found, disables 'probe' tool, please install elfutils-libelf-devel/libelf-dev);
328		328
329	NO_LIBELF := 1	329	NO_LIBELF := 1
330	NO_DWARF := 1	330	NO_DWARF := 1
331	NO_DEMANGLE := 1	331	NO_DEMANGLE := 1
332	NO_LIBUNWIND := 1	332	NO_LIBUNWIND := 1
333	NO_LIBDW_DWARF_UNWIND := 1	333	NO_LIBDW_DWARF_UNWIND := 1
334	else	334	else
335	ifneq ($(filter s% -static%,$(LDFLAGS),),)	335	ifneq ($(filter s% -static%,$(LDFLAGS),),)
336	msg := $(error No static glibc found, please install glibc-static);	336	msg := $(error No static glibc found, please install glibc-static);
337	else	337	else
338	msg := $(error No gnu/libc-version.h found, please install glibc-dev[el]);	338	msg := $(error No gnu/libc-version.h found, please install glibc-dev[el]);
339	endif	339	endif
340	endif	340	endif
341	else	341	else
342	ifndef NO_LIBDW_DWARF_UNWIND	342	ifndef NO_LIBDW_DWARF_UNWIND
343	ifneq ($(feature-libdw-dwarf-unwind),1)	343	ifneq ($(feature-libdw-dwarf-unwind),1)
344	NO_LIBDW_DWARF_UNWIND := 1	344	NO_LIBDW_DWARF_UNWIND := 1
345	msg := $(warning No libdw DWARF unwind found, Please install elfutils-devel/libdw-dev >= 0.158 and/or set LIBDW_DIR);	345	msg := $(warning No libdw DWARF unwind found, Please install elfutils-devel/libdw-dev >= 0.158 and/or set LIBDW_DIR);
346	endif	346	endif
347	endif	347	endif
348	ifneq ($(feature-dwarf), 1)	348	ifneq ($(feature-dwarf), 1)
349	msg := $(warning No libdw.h found or old libdw.h found or elfutils is older than 0.138, disables dwarf support. Please install new elfutils-devel/libdw-dev);	349	msg := $(warning No libdw.h found or old libdw.h found or elfutils is older than 0.138, disables dwarf support. Please install new elfutils-devel/libdw-dev);
350	NO_DWARF := 1	350	NO_DWARF := 1
351	endif # Dwarf support	351	endif # Dwarf support
352	endif # libelf support	352	endif # libelf support
353	endif # NO_LIBELF	353	endif # NO_LIBELF
354		354
355	ifndef NO_LIBELF	355	ifndef NO_LIBELF
356	CFLAGS += -DHAVE_LIBELF_SUPPORT	356	CFLAGS += -DHAVE_LIBELF_SUPPORT
357	EXTLIBS += -lelf	357	EXTLIBS += -lelf
358		358
359	ifeq ($(feature-libelf-mmap), 1)	359	ifeq ($(feature-libelf-mmap), 1)
360	CFLAGS += -DHAVE_LIBELF_MMAP_SUPPORT	360	CFLAGS += -DHAVE_LIBELF_MMAP_SUPPORT
361	endif	361	endif
362		362
363	ifeq ($(feature-libelf-getphdrnum), 1)	363	ifeq ($(feature-libelf-getphdrnum), 1)
364	CFLAGS += -DHAVE_ELF_GETPHDRNUM_SUPPORT	364	CFLAGS += -DHAVE_ELF_GETPHDRNUM_SUPPORT
365	endif	365	endif
366		366
367	# include ARCH specific config	367	# include ARCH specific config
368	-include $(src-perf)/arch/$(ARCH)/Makefile	368	-include $(src-perf)/arch/$(ARCH)/Makefile
369		369
370	ifndef NO_DWARF	370	ifndef NO_DWARF
371	ifeq ($(origin PERF_HAVE_DWARF_REGS), undefined)	371	ifeq ($(origin PERF_HAVE_DWARF_REGS), undefined)
372	msg := $(warning DWARF register mappings have not been defined for architecture $(ARCH), DWARF support disabled);	372	msg := $(warning DWARF register mappings have not been defined for architecture $(ARCH), DWARF support disabled);
373	NO_DWARF := 1	373	NO_DWARF := 1
374	else	374	else
375	CFLAGS += -DHAVE_DWARF_SUPPORT $(LIBDW_CFLAGS)	375	CFLAGS += -DHAVE_DWARF_SUPPORT $(LIBDW_CFLAGS)
376	LDFLAGS += $(LIBDW_LDFLAGS)	376	LDFLAGS += $(LIBDW_LDFLAGS)
377	EXTLIBS += -ldw	377	EXTLIBS += -ldw
378	endif # PERF_HAVE_DWARF_REGS	378	endif # PERF_HAVE_DWARF_REGS
379	endif # NO_DWARF	379	endif # NO_DWARF
380	endif # NO_LIBELF	380	endif # NO_LIBELF
381		381
382	ifeq ($(ARCH),powerpc)	382	ifeq ($(ARCH),powerpc)
383	ifndef NO_DWARF	383	ifndef NO_DWARF
384	CFLAGS += -DHAVE_SKIP_CALLCHAIN_IDX	384	CFLAGS += -DHAVE_SKIP_CALLCHAIN_IDX
385	endif	385	endif
386	endif	386	endif
387		387
388	ifndef NO_LIBUNWIND	388	ifndef NO_LIBUNWIND
389	ifneq ($(feature-libunwind), 1)	389	ifneq ($(feature-libunwind), 1)
390	msg := $(warning No libunwind found. Please install libunwind-dev[el] >= 1.1 and/or set LIBUNWIND_DIR);	390	msg := $(warning No libunwind found. Please install libunwind-dev[el] >= 1.1 and/or set LIBUNWIND_DIR);
391	NO_LIBUNWIND := 1	391	NO_LIBUNWIND := 1
392	endif	392	endif
393	endif	393	endif
394		394
395	dwarf-post-unwind := 1	395	dwarf-post-unwind := 1
396	dwarf-post-unwind-text := BUG	396	dwarf-post-unwind-text := BUG
397		397
398	# setup DWARF post unwinder	398	# setup DWARF post unwinder
399	ifdef NO_LIBUNWIND	399	ifdef NO_LIBUNWIND
400	ifdef NO_LIBDW_DWARF_UNWIND	400	ifdef NO_LIBDW_DWARF_UNWIND
401	msg := $(warning Disabling post unwind, no support found.);	401	msg := $(warning Disabling post unwind, no support found.);
402	dwarf-post-unwind := 0	402	dwarf-post-unwind := 0
403	else	403	else
404	dwarf-post-unwind-text := libdw	404	dwarf-post-unwind-text := libdw
405	endif	405	endif
406	else	406	else
407	dwarf-post-unwind-text := libunwind	407	dwarf-post-unwind-text := libunwind
408	# Enable libunwind support by default.	408	# Enable libunwind support by default.
409	ifndef NO_LIBDW_DWARF_UNWIND	409	ifndef NO_LIBDW_DWARF_UNWIND
410	NO_LIBDW_DWARF_UNWIND := 1	410	NO_LIBDW_DWARF_UNWIND := 1
411	endif	411	endif
412	endif	412	endif
413		413
414	ifeq ($(dwarf-post-unwind),1)	414	ifeq ($(dwarf-post-unwind),1)
415	CFLAGS += -DHAVE_DWARF_UNWIND_SUPPORT	415	CFLAGS += -DHAVE_DWARF_UNWIND_SUPPORT
416	else	416	else
417	NO_DWARF_UNWIND := 1	417	NO_DWARF_UNWIND := 1
418	endif	418	endif
419		419
420	ifndef NO_LIBUNWIND	420	ifndef NO_LIBUNWIND
421	ifeq ($(ARCH),$(filter $(ARCH),arm arm64))	421	ifeq ($(ARCH),$(filter $(ARCH),arm arm64))
422	$(call feature_check,libunwind-debug-frame)	422	$(call feature_check,libunwind-debug-frame)
423	ifneq ($(feature-libunwind-debug-frame), 1)	423	ifneq ($(feature-libunwind-debug-frame), 1)
424	msg := $(warning No debug_frame support found in libunwind);	424	msg := $(warning No debug_frame support found in libunwind);
425	CFLAGS += -DNO_LIBUNWIND_DEBUG_FRAME	425	CFLAGS += -DNO_LIBUNWIND_DEBUG_FRAME
426	endif	426	endif
427	else	427	else
428	# non-ARM has no dwarf_find_debug_frame() function:	428	# non-ARM has no dwarf_find_debug_frame() function:
429	CFLAGS += -DNO_LIBUNWIND_DEBUG_FRAME	429	CFLAGS += -DNO_LIBUNWIND_DEBUG_FRAME
430	endif	430	endif
431	CFLAGS += -DHAVE_LIBUNWIND_SUPPORT	431	CFLAGS += -DHAVE_LIBUNWIND_SUPPORT
432	EXTLIBS += $(LIBUNWIND_LIBS)	432	EXTLIBS += $(LIBUNWIND_LIBS)
433	CFLAGS += $(LIBUNWIND_CFLAGS)	433	CFLAGS += $(LIBUNWIND_CFLAGS)
434	LDFLAGS += $(LIBUNWIND_LDFLAGS)	434	LDFLAGS += $(LIBUNWIND_LDFLAGS)
435	endif	435	endif
436		436
437	ifndef NO_LIBAUDIT	437	ifndef NO_LIBAUDIT
438	ifneq ($(feature-libaudit), 1)	438	ifneq ($(feature-libaudit), 1)
439	msg := $(warning No libaudit.h found, disables 'trace' tool, please install audit-libs-devel or libaudit-dev);	439	msg := $(warning No libaudit.h found, disables 'trace' tool, please install audit-libs-devel or libaudit-dev);
440	NO_LIBAUDIT := 1	440	NO_LIBAUDIT := 1
441	else	441	else
442	CFLAGS += -DHAVE_LIBAUDIT_SUPPORT	442	CFLAGS += -DHAVE_LIBAUDIT_SUPPORT
443	EXTLIBS += -laudit	443	EXTLIBS += -laudit
444	endif	444	endif
445	endif	445	endif
446		446
447	ifdef NO_NEWT	447	ifdef NO_NEWT
448	NO_SLANG=1	448	NO_SLANG=1
449	endif	449	endif
450		450
451	ifndef NO_SLANG	451	ifndef NO_SLANG
452	ifneq ($(feature-libslang), 1)	452	ifneq ($(feature-libslang), 1)
453	msg := $(warning slang not found, disables TUI support. Please install slang-devel or libslang-dev);	453	msg := $(warning slang not found, disables TUI support. Please install slang-devel or libslang-dev);
454	NO_SLANG := 1	454	NO_SLANG := 1
455	else	455	else
456	# Fedora has /usr/include/slang/slang.h, but ubuntu /usr/include/slang.h	456	# Fedora has /usr/include/slang/slang.h, but ubuntu /usr/include/slang.h
457	CFLAGS += -I/usr/include/slang	457	CFLAGS += -I/usr/include/slang
458	CFLAGS += -DHAVE_SLANG_SUPPORT	458	CFLAGS += -DHAVE_SLANG_SUPPORT
459	EXTLIBS += -lslang	459	EXTLIBS += -lslang
460	endif	460	endif
461	endif	461	endif
462		462
463	ifndef NO_GTK2	463	ifndef NO_GTK2
464	FLAGS_GTK2=$(CFLAGS) $(LDFLAGS) $(EXTLIBS) $(shell $(PKG_CONFIG) --libs --cflags gtk+-2.0 2>/dev/null)	464	FLAGS_GTK2=$(CFLAGS) $(LDFLAGS) $(EXTLIBS) $(shell $(PKG_CONFIG) --libs --cflags gtk+-2.0 2>/dev/null)
465	ifneq ($(feature-gtk2), 1)	465	ifneq ($(feature-gtk2), 1)
466	msg := $(warning GTK2 not found, disables GTK2 support. Please install gtk2-devel or libgtk2.0-dev);	466	msg := $(warning GTK2 not found, disables GTK2 support. Please install gtk2-devel or libgtk2.0-dev);
467	NO_GTK2 := 1	467	NO_GTK2 := 1
468	else	468	else
469	ifeq ($(feature-gtk2-infobar), 1)	469	ifeq ($(feature-gtk2-infobar), 1)
470	GTK_CFLAGS := -DHAVE_GTK_INFO_BAR_SUPPORT	470	GTK_CFLAGS := -DHAVE_GTK_INFO_BAR_SUPPORT
471	endif	471	endif
472	CFLAGS += -DHAVE_GTK2_SUPPORT	472	CFLAGS += -DHAVE_GTK2_SUPPORT
473	GTK_CFLAGS += $(shell $(PKG_CONFIG) --cflags gtk+-2.0 2>/dev/null)	473	GTK_CFLAGS += $(shell $(PKG_CONFIG) --cflags gtk+-2.0 2>/dev/null)
474	GTK_LIBS := $(shell $(PKG_CONFIG) --libs gtk+-2.0 2>/dev/null)	474	GTK_LIBS := $(shell $(PKG_CONFIG) --libs gtk+-2.0 2>/dev/null)
475	EXTLIBS += -ldl	475	EXTLIBS += -ldl
476	endif	476	endif
477	endif	477	endif
478		478
479	grep-libs = $(filter -l%,$(1))	479	grep-libs = $(filter -l%,$(1))
480	strip-libs = $(filter-out -l%,$(1))	480	strip-libs = $(filter-out -l%,$(1))
481		481
482	ifdef NO_LIBPERL	482	ifdef NO_LIBPERL
483	CFLAGS += -DNO_LIBPERL	483	CFLAGS += -DNO_LIBPERL
484	else	484	else
485	PERL_EMBED_LDOPTS = $(shell perl -MExtUtils::Embed -e ldopts 2>/dev/null)	485	PERL_EMBED_LDOPTS = $(shell perl -MExtUtils::Embed -e ldopts 2>/dev/null)
486	PERL_EMBED_LDFLAGS = $(call strip-libs,$(PERL_EMBED_LDOPTS))	486	PERL_EMBED_LDFLAGS = $(call strip-libs,$(PERL_EMBED_LDOPTS))
487	PERL_EMBED_LIBADD = $(call grep-libs,$(PERL_EMBED_LDOPTS))	487	PERL_EMBED_LIBADD = $(call grep-libs,$(PERL_EMBED_LDOPTS))
488	PERL_EMBED_CCOPTS = `perl -MExtUtils::Embed -e ccopts 2>/dev/null`	488	PERL_EMBED_CCOPTS = `perl -MExtUtils::Embed -e ccopts 2>/dev/null`
489	FLAGS_PERL_EMBED=$(PERL_EMBED_CCOPTS) $(PERL_EMBED_LDOPTS)	489	FLAGS_PERL_EMBED=$(PERL_EMBED_CCOPTS) $(PERL_EMBED_LDOPTS)
490		490
491	ifneq ($(feature-libperl), 1)	491	ifneq ($(feature-libperl), 1)
492	CFLAGS += -DNO_LIBPERL	492	CFLAGS += -DNO_LIBPERL
493	NO_LIBPERL := 1	493	NO_LIBPERL := 1
494	msg := $(warning Missing perl devel files. Disabling perl scripting support, consider installing perl-ExtUtils-Embed);	494	msg := $(warning Missing perl devel files. Disabling perl scripting support, consider installing perl-ExtUtils-Embed);
495	else	495	else
496	LDFLAGS += $(PERL_EMBED_LDFLAGS)	496	LDFLAGS += $(PERL_EMBED_LDFLAGS)
497	EXTLIBS += $(PERL_EMBED_LIBADD)	497	EXTLIBS += $(PERL_EMBED_LIBADD)
498	endif	498	endif
499	endif	499	endif
500		500
501	ifeq ($(feature-timerfd), 1)	501	ifeq ($(feature-timerfd), 1)
502	CFLAGS += -DHAVE_TIMERFD_SUPPORT	502	CFLAGS += -DHAVE_TIMERFD_SUPPORT
503	else	503	else
504	msg := $(warning No timerfd support. Disables 'perf kvm stat live');	504	msg := $(warning No timerfd support. Disables 'perf kvm stat live');
505	endif	505	endif
506		506
507	disable-python = $(eval $(disable-python_code))	507	disable-python = $(eval $(disable-python_code))
508	define disable-python_code	508	define disable-python_code
509	CFLAGS += -DNO_LIBPYTHON	509	CFLAGS += -DNO_LIBPYTHON
510	$(if $(1),$(warning No $(1) was found))	510	$(if $(1),$(warning No $(1) was found))
511	$(warning Python support will not be built)	511	$(warning Python support will not be built)
512	NO_LIBPYTHON := 1	512	NO_LIBPYTHON := 1
513	endef	513	endef
514		514
515	ifdef NO_LIBPYTHON	515	ifdef NO_LIBPYTHON
516	$(call disable-python)	516	$(call disable-python)
517	else	517	else
518		518
519	ifndef PYTHON	519	ifndef PYTHON
520	$(call disable-python,python interpreter)	520	$(call disable-python,python interpreter)
521	else	521	else
522	PYTHON_WORD := $(call shell-wordify,$(PYTHON))	522	PYTHON_WORD := $(call shell-wordify,$(PYTHON))
523		523
524	ifndef PYTHON_CONFIG	524	ifndef PYTHON_CONFIG
525	$(call disable-python,python-config tool)	525	$(call disable-python,python-config tool)
526	else	526	else
527		527
528	PYTHON_CONFIG_SQ := $(call shell-sq,$(PYTHON_CONFIG))	528	PYTHON_CONFIG_SQ := $(call shell-sq,$(PYTHON_CONFIG))
529		529
530	PYTHON_EMBED_LDOPTS := $(shell $(PYTHON_CONFIG_SQ) --ldflags 2>/dev/null)	530	PYTHON_EMBED_LDOPTS := $(shell $(PYTHON_CONFIG_SQ) --ldflags 2>/dev/null)
531	PYTHON_EMBED_LDFLAGS := $(call strip-libs,$(PYTHON_EMBED_LDOPTS))	531	PYTHON_EMBED_LDFLAGS := $(call strip-libs,$(PYTHON_EMBED_LDOPTS))
532	PYTHON_EMBED_LIBADD := $(call grep-libs,$(PYTHON_EMBED_LDOPTS))	532	PYTHON_EMBED_LIBADD := $(call grep-libs,$(PYTHON_EMBED_LDOPTS))
533	PYTHON_EMBED_CCOPTS := $(shell $(PYTHON_CONFIG_SQ) --cflags 2>/dev/null)	533	PYTHON_EMBED_CCOPTS := $(shell $(PYTHON_CONFIG_SQ) --cflags 2>/dev/null)
534	FLAGS_PYTHON_EMBED := $(PYTHON_EMBED_CCOPTS) $(PYTHON_EMBED_LDOPTS)	534	FLAGS_PYTHON_EMBED := $(PYTHON_EMBED_CCOPTS) $(PYTHON_EMBED_LDOPTS)
535		535
536	ifneq ($(feature-libpython), 1)	536	ifneq ($(feature-libpython), 1)
537	$(call disable-python,Python.h (for Python 2.x))	537	$(call disable-python,Python.h (for Python 2.x))
538	else	538	else
539		539
540	ifneq ($(feature-libpython-version), 1)	540	ifneq ($(feature-libpython-version), 1)
541	$(warning Python 3 is not yet supported; please set)	541	$(warning Python 3 is not yet supported; please set)
542	$(warning PYTHON and/or PYTHON_CONFIG appropriately.)	542	$(warning PYTHON and/or PYTHON_CONFIG appropriately.)
543	$(warning If you also have Python 2 installed, then)	543	$(warning If you also have Python 2 installed, then)
544	$(warning try something like:)	544	$(warning try something like:)
545	$(warning $(and ,))	545	$(warning $(and ,))
546	$(warning $(and ,) make PYTHON=python2)	546	$(warning $(and ,) make PYTHON=python2)
547	$(warning $(and ,))	547	$(warning $(and ,))
548	$(warning Otherwise, disable Python support entirely:)	548	$(warning Otherwise, disable Python support entirely:)
549	$(warning $(and ,))	549	$(warning $(and ,))
550	$(warning $(and ,) make NO_LIBPYTHON=1)	550	$(warning $(and ,) make NO_LIBPYTHON=1)
551	$(warning $(and ,))	551	$(warning $(and ,))
552	$(error $(and ,))	552	$(error $(and ,))
553	else	553	else
554	LDFLAGS += $(PYTHON_EMBED_LDFLAGS)	554	LDFLAGS += $(PYTHON_EMBED_LDFLAGS)
555	EXTLIBS += $(PYTHON_EMBED_LIBADD)	555	EXTLIBS += $(PYTHON_EMBED_LIBADD)
556	LANG_BINDINGS += $(obj-perf)python/perf.so	556	LANG_BINDINGS += $(obj-perf)python/perf.so
557	endif	557	endif
558	endif	558	endif
559	endif	559	endif
560	endif	560	endif
561	endif	561	endif
562		562
563	ifeq ($(feature-libbfd), 1)	563	ifeq ($(feature-libbfd), 1)
564	EXTLIBS += -lbfd	564	EXTLIBS += -lbfd
565		565
566	# call all detections now so we get correct	566	# call all detections now so we get correct
567	# status in VF output	567	# status in VF output
568	$(call feature_check,liberty)	568	$(call feature_check,liberty)
569	$(call feature_check,liberty-z)	569	$(call feature_check,liberty-z)
570	$(call feature_check,cplus-demangle)	570	$(call feature_check,cplus-demangle)
571		571
572	ifeq ($(feature-liberty), 1)	572	ifeq ($(feature-liberty), 1)
573	EXTLIBS += -liberty	573	EXTLIBS += -liberty
574	else	574	else
575	ifeq ($(feature-liberty-z), 1)	575	ifeq ($(feature-liberty-z), 1)
576	EXTLIBS += -liberty -lz	576	EXTLIBS += -liberty -lz
577	endif	577	endif
578	endif	578	endif
579	endif	579	endif
580		580
581	ifdef NO_DEMANGLE	581	ifdef NO_DEMANGLE
582	CFLAGS += -DNO_DEMANGLE	582	CFLAGS += -DNO_DEMANGLE
583	else	583	else
584	ifdef HAVE_CPLUS_DEMANGLE_SUPPORT	584	ifdef HAVE_CPLUS_DEMANGLE_SUPPORT
585	EXTLIBS += -liberty	585	EXTLIBS += -liberty
586	CFLAGS += -DHAVE_CPLUS_DEMANGLE_SUPPORT	586	CFLAGS += -DHAVE_CPLUS_DEMANGLE_SUPPORT
587	else	587	else
588	ifneq ($(feature-libbfd), 1)	588	ifneq ($(feature-libbfd), 1)
589	ifneq ($(feature-liberty), 1)	589	ifneq ($(feature-liberty), 1)
590	ifneq ($(feature-liberty-z), 1)	590	ifneq ($(feature-liberty-z), 1)
591	# we dont have neither HAVE_CPLUS_DEMANGLE_SUPPORT	591	# we dont have neither HAVE_CPLUS_DEMANGLE_SUPPORT
592	# or any of 'bfd iberty z' trinity	592	# or any of 'bfd iberty z' trinity
593	ifeq ($(feature-cplus-demangle), 1)	593	ifeq ($(feature-cplus-demangle), 1)
594	EXTLIBS += -liberty	594	EXTLIBS += -liberty
595	CFLAGS += -DHAVE_CPLUS_DEMANGLE_SUPPORT	595	CFLAGS += -DHAVE_CPLUS_DEMANGLE_SUPPORT
596	else	596	else
597	msg := $(warning No bfd.h/libbfd found, install binutils-dev[el]/zlib-static to gain symbol demangling)	597	msg := $(warning No bfd.h/libbfd found, install binutils-dev[el]/zlib-static to gain symbol demangling)
598	CFLAGS += -DNO_DEMANGLE	598	CFLAGS += -DNO_DEMANGLE
599	endif	599	endif
600	endif	600	endif
601	endif	601	endif
602	endif	602	endif
603	endif	603	endif
604	endif	604	endif
605		605
606	ifneq ($(filter -lbfd,$(EXTLIBS)),)	606	ifneq ($(filter -lbfd,$(EXTLIBS)),)
607	CFLAGS += -DHAVE_LIBBFD_SUPPORT	607	CFLAGS += -DHAVE_LIBBFD_SUPPORT
608	endif	608	endif
609		609
610	ifndef NO_ZLIB	610	ifndef NO_ZLIB
611	ifeq ($(feature-zlib), 1)	611	ifeq ($(feature-zlib), 1)
612	CFLAGS += -DHAVE_ZLIB_SUPPORT	612	CFLAGS += -DHAVE_ZLIB_SUPPORT
613	EXTLIBS += -lz	613	EXTLIBS += -lz
614	else	614	else
615	NO_ZLIB := 1	615	NO_ZLIB := 1
616	endif	616	endif
617	endif	617	endif
618		618
619	ifndef NO_BACKTRACE	619	ifndef NO_BACKTRACE
620	ifeq ($(feature-backtrace), 1)	620	ifeq ($(feature-backtrace), 1)
621	CFLAGS += -DHAVE_BACKTRACE_SUPPORT	621	CFLAGS += -DHAVE_BACKTRACE_SUPPORT
622	endif	622	endif
623	endif	623	endif
624		624
625	ifndef NO_LIBNUMA	625	ifndef NO_LIBNUMA
626	ifeq ($(feature-libnuma), 0)	626	ifeq ($(feature-libnuma), 0)
627	msg := $(warning No numa.h found, disables 'perf bench numa mem' benchmark, please install numactl-devel/libnuma-devel/libnuma-dev);	627	msg := $(warning No numa.h found, disables 'perf bench numa mem' benchmark, please install numactl-devel/libnuma-devel/libnuma-dev);
628	NO_LIBNUMA := 1	628	NO_LIBNUMA := 1
629	else	629	else
630	CFLAGS += -DHAVE_LIBNUMA_SUPPORT	630	CFLAGS += -DHAVE_LIBNUMA_SUPPORT
631	EXTLIBS += -lnuma	631	EXTLIBS += -lnuma
632	endif	632	endif
633	endif	633	endif
634		634
635	ifdef HAVE_KVM_STAT_SUPPORT	635	ifdef HAVE_KVM_STAT_SUPPORT
636	CFLAGS += -DHAVE_KVM_STAT_SUPPORT	636	CFLAGS += -DHAVE_KVM_STAT_SUPPORT
637	endif	637	endif
638		638
639	ifeq (${IS_64_BIT}, 1)	639	ifeq (${IS_64_BIT}, 1)
640	ifndef NO_PERF_READ_VDSO32	640	ifndef NO_PERF_READ_VDSO32
641	$(call feature_check,compile-32)	641	$(call feature_check,compile-32)
642	ifeq ($(feature-compile-32), 1)	642	ifeq ($(feature-compile-32), 1)
643	CFLAGS += -DHAVE_PERF_READ_VDSO32	643	CFLAGS += -DHAVE_PERF_READ_VDSO32
644	else	644	else
645	NO_PERF_READ_VDSO32 := 1	645	NO_PERF_READ_VDSO32 := 1
646	endif	646	endif
647	endif	647	endif
648	ifneq (${IS_X86_64}, 1)	648	ifneq (${IS_X86_64}, 1)
649	NO_PERF_READ_VDSOX32 := 1	649	NO_PERF_READ_VDSOX32 := 1
650	endif	650	endif
651	ifndef NO_PERF_READ_VDSOX32	651	ifndef NO_PERF_READ_VDSOX32
652	$(call feature_check,compile-x32)	652	$(call feature_check,compile-x32)
653	ifeq ($(feature-compile-x32), 1)	653	ifeq ($(feature-compile-x32), 1)
654	CFLAGS += -DHAVE_PERF_READ_VDSOX32	654	CFLAGS += -DHAVE_PERF_READ_VDSOX32
655	else	655	else
656	NO_PERF_READ_VDSOX32 := 1	656	NO_PERF_READ_VDSOX32 := 1
657	endif	657	endif
658	endif	658	endif
659	else	659	else
660	NO_PERF_READ_VDSO32 := 1	660	NO_PERF_READ_VDSO32 := 1
661	NO_PERF_READ_VDSOX32 := 1	661	NO_PERF_READ_VDSOX32 := 1
662	endif	662	endif
663		663
664	# Among the variables below, these:	664	# Among the variables below, these:
665	# perfexecdir	665	# perfexecdir
666	# template_dir	666	# template_dir
667	# mandir	667	# mandir
668	# infodir	668	# infodir
669	# htmldir	669	# htmldir
670	# ETC_PERFCONFIG (but not sysconfdir)	670	# ETC_PERFCONFIG (but not sysconfdir)
671	# can be specified as a relative path some/where/else;	671	# can be specified as a relative path some/where/else;
672	# this is interpreted as relative to $(prefix) and "perf" at	672	# this is interpreted as relative to $(prefix) and "perf" at
673	# runtime figures out where they are based on the path to the executable.	673	# runtime figures out where they are based on the path to the executable.
674	# This can help installing the suite in a relocatable way.	674	# This can help installing the suite in a relocatable way.
675		675
676	# Make the path relative to DESTDIR, not to prefix	676	# Make the path relative to DESTDIR, not to prefix
677	ifndef DESTDIR	677	ifndef DESTDIR
678	prefix ?= $(HOME)	678	prefix ?= $(HOME)
679	endif	679	endif
680	bindir_relative = bin	680	bindir_relative = bin
681	bindir = $(prefix)/$(bindir_relative)	681	bindir = $(prefix)/$(bindir_relative)
682	mandir = share/man	682	mandir = share/man
683	infodir = share/info	683	infodir = share/info
684	perfexecdir = libexec/perf-core	684	perfexecdir = libexec/perf-core
685	sharedir = $(prefix)/share	685	sharedir = $(prefix)/share
686	template_dir = share/perf-core/templates	686	template_dir = share/perf-core/templates
687	htmldir = share/doc/perf-doc	687	htmldir = share/doc/perf-doc
688	ifeq ($(prefix),/usr)	688	ifeq ($(prefix),/usr)
689	sysconfdir = /etc	689	sysconfdir = /etc
690	ETC_PERFCONFIG = $(sysconfdir)/perfconfig	690	ETC_PERFCONFIG = $(sysconfdir)/perfconfig
691	else	691	else
692	sysconfdir = $(prefix)/etc	692	sysconfdir = $(prefix)/etc
693	ETC_PERFCONFIG = etc/perfconfig	693	ETC_PERFCONFIG = etc/perfconfig
694	endif	694	endif
695	ifndef lib	695	ifndef lib
696	ifeq ($(IS_X86_64),1)	696	ifeq ($(IS_X86_64),1)
697	lib = lib64	697	lib = lib64
698	else	698	else
699	lib = lib	699	lib = lib
700	endif	700	endif
701	endif # lib	701	endif # lib
702	libdir = $(prefix)/$(lib)	702	libdir = $(prefix)/$(lib)
703		703
704	# Shell quote (do not use $(call) to accommodate ancient setups);	704	# Shell quote (do not use $(call) to accommodate ancient setups);
705	ETC_PERFCONFIG_SQ = $(subst ','\'',$(ETC_PERFCONFIG))	705	ETC_PERFCONFIG_SQ = $(subst ','\'',$(ETC_PERFCONFIG))
706	DESTDIR_SQ = $(subst ','\'',$(DESTDIR))	706	DESTDIR_SQ = $(subst ','\'',$(DESTDIR))
707	bindir_SQ = $(subst ','\'',$(bindir))	707	bindir_SQ = $(subst ','\'',$(bindir))
708	mandir_SQ = $(subst ','\'',$(mandir))	708	mandir_SQ = $(subst ','\'',$(mandir))
709	infodir_SQ = $(subst ','\'',$(infodir))	709	infodir_SQ = $(subst ','\'',$(infodir))
710	perfexecdir_SQ = $(subst ','\'',$(perfexecdir))	710	perfexecdir_SQ = $(subst ','\'',$(perfexecdir))
711	template_dir_SQ = $(subst ','\'',$(template_dir))	711	template_dir_SQ = $(subst ','\'',$(template_dir))
712	htmldir_SQ = $(subst ','\'',$(htmldir))	712	htmldir_SQ = $(subst ','\'',$(htmldir))
713	prefix_SQ = $(subst ','\'',$(prefix))	713	prefix_SQ = $(subst ','\'',$(prefix))
714	sysconfdir_SQ = $(subst ','\'',$(sysconfdir))	714	sysconfdir_SQ = $(subst ','\'',$(sysconfdir))
715	libdir_SQ = $(subst ','\'',$(libdir))	715	libdir_SQ = $(subst ','\'',$(libdir))
716		716
717	ifneq ($(filter /%,$(firstword $(perfexecdir))),)	717	ifneq ($(filter /%,$(firstword $(perfexecdir))),)
718	perfexec_instdir = $(perfexecdir)	718	perfexec_instdir = $(perfexecdir)
719	else	719	else
720	perfexec_instdir = $(prefix)/$(perfexecdir)	720	perfexec_instdir = $(prefix)/$(perfexecdir)
721	endif	721	endif
722	perfexec_instdir_SQ = $(subst ','\'',$(perfexec_instdir))	722	perfexec_instdir_SQ = $(subst ','\'',$(perfexec_instdir))
723		723
724	# If we install to $(HOME) we keep the traceevent default:	724	# If we install to $(HOME) we keep the traceevent default:
725	# $(HOME)/.traceevent/plugins	725	# $(HOME)/.traceevent/plugins
726	# Otherwise we install plugins into the global $(libdir).	726	# Otherwise we install plugins into the global $(libdir).
727	ifdef DESTDIR	727	ifdef DESTDIR
728	plugindir=$(libdir)/traceevent/plugins	728	plugindir=$(libdir)/traceevent/plugins
729	plugindir_SQ= $(subst ','\'',$(plugindir))	729	plugindir_SQ= $(subst ','\'',$(plugindir))
730	endif	730	endif
731		731
732	#	732	#
733	# Print the result of the feature test:	733	# Print the result of the feature test:
734	#	734	#
735	feature_print_status = $(eval $(feature_print_status_code)) $(info $(MSG))	735	feature_print_status = $(eval $(feature_print_status_code)) $(info $(MSG))
736		736
737	define feature_print_status_code	737	define feature_print_status_code
738	ifeq ($(feature-$(1)), 1)	738	ifeq ($(feature-$(1)), 1)
739	MSG = $(shell printf '...%30s: [ \033[32mon\033[m ]' $(1))	739	MSG = $(shell printf '...%30s: [ \033[32mon\033[m ]' $(1))
740	else	740	else
741	MSG = $(shell printf '...%30s: [ \033[31mOFF\033[m ]' $(1))	741	MSG = $(shell printf '...%30s: [ \033[31mOFF\033[m ]' $(1))
742	endif	742	endif
743	endef	743	endef
744		744
745	feature_print_var = $(eval $(feature_print_var_code)) $(info $(MSG))	745	feature_print_var = $(eval $(feature_print_var_code)) $(info $(MSG))
746	define feature_print_var_code	746	define feature_print_var_code
747	MSG = $(shell printf '...%30s: %s' $(1) $($(1)))	747	MSG = $(shell printf '...%30s: %s' $(1) $($(1)))
748	endef	748	endef
749		749
750	feature_print_text = $(eval $(feature_print_text_code)) $(info $(MSG))	750	feature_print_text = $(eval $(feature_print_text_code)) $(info $(MSG))
751	define feature_print_text_code	751	define feature_print_text_code
752	MSG = $(shell printf '...%30s: %s' $(1) $(2))	752	MSG = $(shell printf '...%30s: %s' $(1) $(2))
753	endef	753	endef
754		754
755	PERF_FEATURES := $(foreach feat,$(LIB_FEATURE_TESTS),feature-$(feat)($(feature-$(feat))))	755	PERF_FEATURES := $(foreach feat,$(LIB_FEATURE_TESTS),feature-$(feat)($(feature-$(feat))))
756	PERF_FEATURES_FILE := $(shell touch $(OUTPUT)PERF-FEATURES; cat $(OUTPUT)PERF-FEATURES)	756	PERF_FEATURES_FILE := $(shell touch $(OUTPUT)PERF-FEATURES; cat $(OUTPUT)PERF-FEATURES)
757		757
758	ifeq ($(dwarf-post-unwind),1)	758	ifeq ($(dwarf-post-unwind),1)
759	PERF_FEATURES += dwarf-post-unwind($(dwarf-post-unwind-text))	759	PERF_FEATURES += dwarf-post-unwind($(dwarf-post-unwind-text))
760	endif	760	endif
761		761
762	# The $(display_lib) controls the default detection message	762	# The $(display_lib) controls the default detection message
763	# output. It's set if:	763	# output. It's set if:
764	# - detected features differes from stored features from	764	# - detected features differes from stored features from
765	# last build (in PERF-FEATURES file)	765	# last build (in PERF-FEATURES file)
766	# - one of the $(LIB_FEATURE_TESTS) is not detected	766	# - one of the $(LIB_FEATURE_TESTS) is not detected
767	# - VF is enabled	767	# - VF is enabled
768		768
769	ifneq ("$(PERF_FEATURES)","$(PERF_FEATURES_FILE)")	769	ifneq ("$(PERF_FEATURES)","$(PERF_FEATURES_FILE)")
770	$(shell echo "$(PERF_FEATURES)" > $(OUTPUT)PERF-FEATURES)	770	$(shell echo "$(PERF_FEATURES)" > $(OUTPUT)PERF-FEATURES)
771	display_lib := 1	771	display_lib := 1
772	endif	772	endif
773		773
774	feature_check = $(eval $(feature_check_code))	774	feature_check = $(eval $(feature_check_code))
775	define feature_check_code	775	define feature_check_code
776	ifneq ($(feature-$(1)), 1)	776	ifneq ($(feature-$(1)), 1)
777	display_lib := 1	777	display_lib := 1
778	endif	778	endif
779	endef	779	endef
780		780
781	$(foreach feat,$(LIB_FEATURE_TESTS),$(call feature_check,$(feat)))	781	$(foreach feat,$(LIB_FEATURE_TESTS),$(call feature_check,$(feat)))
782		782
783	ifeq ($(VF),1)	783	ifeq ($(VF),1)
784	display_lib := 1	784	display_lib := 1
785	display_vf := 1	785	display_vf := 1
786	endif	786	endif
787		787
788	ifeq ($(display_lib),1)	788	ifeq ($(display_lib),1)
789	$(info )	789	$(info )
790	$(info Auto-detecting system features:)	790	$(info Auto-detecting system features:)
791	$(foreach feat,$(LIB_FEATURE_TESTS),$(call feature_print_status,$(feat),))	791	$(foreach feat,$(LIB_FEATURE_TESTS),$(call feature_print_status,$(feat),))
792		792
793	ifeq ($(dwarf-post-unwind),1)	793	ifeq ($(dwarf-post-unwind),1)
794	$(call feature_print_text,"DWARF post unwind library", $(dwarf-post-unwind-text))	794	$(call feature_print_text,"DWARF post unwind library", $(dwarf-post-unwind-text))
795	endif	795	endif
796	endif	796	endif
797		797
798	ifeq ($(display_vf),1)	798	ifeq ($(display_vf),1)
799	$(foreach feat,$(VF_FEATURE_TESTS),$(call feature_print_status,$(feat),))	799	$(foreach feat,$(VF_FEATURE_TESTS),$(call feature_print_status,$(feat),))
800	$(info )	800	$(info )
801	$(call feature_print_var,prefix)	801	$(call feature_print_var,prefix)
802	$(call feature_print_var,bindir)	802	$(call feature_print_var,bindir)
803	$(call feature_print_var,libdir)	803	$(call feature_print_var,libdir)
804	$(call feature_print_var,sysconfdir)	804	$(call feature_print_var,sysconfdir)
805	$(call feature_print_var,LIBUNWIND_DIR)	805	$(call feature_print_var,LIBUNWIND_DIR)
806	$(call feature_print_var,LIBDW_DIR)	806	$(call feature_print_var,LIBDW_DIR)
807	endif	807	endif
808		808
809	ifeq ($(display_lib),1)	809	ifeq ($(display_lib),1)
810	$(info )	810	$(info )
811	endif	811	endif
812		812

tools/perf/config/Makefile.arch

Diff comments View file @ 59b2858

1		1
2	uname_M := $(shell uname -m 2>/dev/null \|\| echo not)	2	uname_M := $(shell uname -m 2>/dev/null \|\| echo not)
3		3
4	ARCH ?= $(shell echo $(uname_M) \| sed -e s/i.86/i386/ -e s/sun4u/sparc64/ \	4	RAW_ARCH := $(shell echo $(uname_M) \| sed -e s/i.86/i386/ -e s/sun4u/sparc64/ \
5	-e s/arm.*/arm/ -e s/sa110/arm/ \	5	-e s/arm.*/arm/ -e s/sa110/arm/ \
6	-e s/s390x/s390/ -e s/parisc64/parisc/ \	6	-e s/s390x/s390/ -e s/parisc64/parisc/ \
7	-e s/ppc./powerpc/ -e s/mips./mips/ \	7	-e s/ppc./powerpc/ -e s/mips./mips/ \
8	-e s/sh[234]./sh/ -e s/aarch64./arm64/ \	8	-e s/sh[234]./sh/ -e s/aarch64./arm64/ \
9	-e s/tile.*/tile/ )	9	-e s/tile.*/tile/ )
10		10
11	# Additional ARCH settings for x86	11	# Additional ARCH settings for x86
12	ifeq ($(ARCH),i386)	12	ifeq ($(RAW_ARCH),i386)
13	override ARCH := x86	13	ARCH ?= x86
14	endif	14	endif
15		15
16	ifeq ($(ARCH),x86_64)	16	ifeq ($(RAW_ARCH),x86_64)
17	override ARCH := x86	17	ARCH ?= x86
18	IS_X86_64 := 0	18
19	ifeq (, $(findstring m32,$(CFLAGS)))	19	ifneq (, $(findstring m32,$(CFLAGS)))
20	IS_X86_64 := $(shell echo __x86_64__ \| ${CC} -E -x c - \| tail -n 1)	20	RAW_ARCH := x86_32
21	RAW_ARCH := x86_64
22	endif	21	endif
23	endif	22	endif
24		23
25	ifeq (${IS_X86_64}, 1)	24	ARCH ?= $(RAW_ARCH)
		25
		26	LP64 := $(shell echo __LP64__ \| ${CC} ${CFLAGS} -E -x c - \| tail -n 1)
		27	ifeq ($(LP64), 1)
26	IS_64_BIT := 1	28	IS_64_BIT := 1
27	else ifeq ($(ARCH),x86)
28	IS_64_BIT := 0
29	else	29	else

tools/perf/perf-sys.h

Diff comments View file @ 59b2858

 #ifndef _PERF_SYS_H
 #define _PERF_SYS_H
 #include <unistd.h>
 #include <sys/types.h>
 #include <sys/syscall.h>
 #include <linux/types.h>
 #include <linux/perf_event.h>
-#include <asm/unistd.h>
 #if defined(__i386__)
 #define mb()		asm volatile("lock; addl $0,0(%%esp)" ::: "memory")
 #define wmb()		asm volatile("lock; addl $0,0(%%esp)" ::: "memory")
 #define rmb()		asm volatile("lock; addl $0,0(%%esp)" ::: "memory")
 #define cpu_relax()	asm volatile("rep; nop" ::: "memory");
 #define CPUINFO_PROC	{"model name"}
 #ifndef __NR_perf_event_open
 # define __NR_perf_event_open 336
 #endif
 #ifndef __NR_futex
 # define __NR_futex 240
 #endif
 #ifndef __NR_gettid
 # define __NR_gettid 224
 #endif
 #endif
 #if defined(__x86_64__)
 #define mb()		asm volatile("mfence" ::: "memory")
 #define wmb()		asm volatile("sfence" ::: "memory")
 #define rmb()		asm volatile("lfence" ::: "memory")
 #define cpu_relax()	asm volatile("rep; nop" ::: "memory");
 #define CPUINFO_PROC	{"model name"}
 #ifndef __NR_perf_event_open
 # define __NR_perf_event_open 298
 #endif
 #ifndef __NR_futex
 # define __NR_futex 202
 #endif
 #ifndef __NR_gettid
 # define __NR_gettid 186
 #endif
 #endif
 #ifdef __powerpc__
 #include "../../arch/powerpc/include/uapi/asm/unistd.h"
 #define mb()		asm volatile ("sync" ::: "memory")
 #define wmb()		asm volatile ("sync" ::: "memory")
 #define rmb()		asm volatile ("sync" ::: "memory")
 #define CPUINFO_PROC	{"cpu"}
 #endif
 #ifdef __s390__
 #define mb()		asm volatile("bcr 15,0" ::: "memory")
 #define wmb()		asm volatile("bcr 15,0" ::: "memory")
 #define rmb()		asm volatile("bcr 15,0" ::: "memory")
 #define CPUINFO_PROC	{"vendor_id"}
 #endif
 #ifdef __sh__
 #if defined(__SH4A__) || defined(__SH5__)
 # define mb()		asm volatile("synco" ::: "memory")
 # define wmb()		asm volatile("synco" ::: "memory")
 # define rmb()		asm volatile("synco" ::: "memory")
 #else
 # define mb()		asm volatile("" ::: "memory")
 # define wmb()		asm volatile("" ::: "memory")
 # define rmb()		asm volatile("" ::: "memory")
 #endif
 #define CPUINFO_PROC	{"cpu type"}
 #endif
 #ifdef __hppa__
 #define mb()		asm volatile("" ::: "memory")
 #define wmb()		asm volatile("" ::: "memory")
 #define rmb()		asm volatile("" ::: "memory")
 #define CPUINFO_PROC	{"cpu"}
 #endif
 #ifdef __sparc__
 #ifdef __LP64__
 #define mb()		asm volatile("ba,pt %%xcc, 1f\n"	\
 				     "membar #StoreLoad\n"	\
 				     "1:\n":::"memory")
 #else
 #define mb()		asm volatile("":::"memory")
 #endif
 #define wmb()		asm volatile("":::"memory")
 #define rmb()		asm volatile("":::"memory")
 #define CPUINFO_PROC	{"cpu"}
 #endif
 #ifdef __alpha__
 #define mb()		asm volatile("mb" ::: "memory")
 #define wmb()		asm volatile("wmb" ::: "memory")
 #define rmb()		asm volatile("mb" ::: "memory")
 #define CPUINFO_PROC	{"cpu model"}
 #endif
 #ifdef __ia64__
 #define mb()		asm volatile ("mf" ::: "memory")
 #define wmb()		asm volatile ("mf" ::: "memory")
 #define rmb()		asm volatile ("mf" ::: "memory")
 #define cpu_relax()	asm volatile ("hint @pause" ::: "memory")
 #define CPUINFO_PROC	{"model name"}
 #endif
 #ifdef __arm__
 /*
  * Use the __kuser_memory_barrier helper in the CPU helper page. See
  * arch/arm/kernel/entry-armv.S in the kernel source for details.
  */
 #define mb()		((void(*)(void))0xffff0fa0)()
 #define wmb()		((void(*)(void))0xffff0fa0)()
 #define rmb()		((void(*)(void))0xffff0fa0)()
 #define CPUINFO_PROC	{"model name", "Processor"}
 #endif
 #ifdef __aarch64__
 #define mb()		asm volatile("dmb ish" ::: "memory")
 #define wmb()		asm volatile("dmb ishst" ::: "memory")
 #define rmb()		asm volatile("dmb ishld" ::: "memory")
 #define cpu_relax()	asm volatile("yield" ::: "memory")
 #endif
 #ifdef __mips__
 #define mb()		asm volatile(					\
 				".set	mips2\n\t"			\
 				"sync\n\t"				\
 				".set	mips0"				\
 				: /* no output */			\
 				: /* no input */			\
 				: "memory")
 #define wmb()	mb()
 #define rmb()	mb()
 #define CPUINFO_PROC	{"cpu model"}
 #endif
 #ifdef __arc__
 #define mb()		asm volatile("" ::: "memory")
 #define wmb()		asm volatile("" ::: "memory")
 #define rmb()		asm volatile("" ::: "memory")
 #define CPUINFO_PROC	{"Processor"}
 #endif
 #ifdef __metag__
 #define mb()		asm volatile("" ::: "memory")
 #define wmb()		asm volatile("" ::: "memory")
 #define rmb()		asm volatile("" ::: "memory")
 #define CPUINFO_PROC	{"CPU"}
 #endif
 #ifdef __xtensa__
 #define mb()		asm volatile("memw" ::: "memory")
 #define wmb()		asm volatile("memw" ::: "memory")
 #define rmb()		asm volatile("" ::: "memory")
 #define CPUINFO_PROC	{"core ID"}
 #endif
 #ifdef __tile__
 #define mb()		asm volatile ("mf" ::: "memory")
 #define wmb()		asm volatile ("mf" ::: "memory")
 #define rmb()		asm volatile ("mf" ::: "memory")
 #define cpu_relax()	asm volatile ("mfspr zero, PASS" ::: "memory")
 #define CPUINFO_PROC    {"model name"}
 #endif
 #define barrier() asm volatile ("" ::: "memory")
 #ifndef cpu_relax
 #define cpu_relax() barrier()
 #endif
 static inline int
 sys_perf_event_open(struct perf_event_attr *attr,
 		      pid_t pid, int cpu, int group_fd,
 		      unsigned long flags)
 {
 	int fd;
 	fd = syscall(__NR_perf_event_open, attr, pid, cpu,
 		     group_fd, flags);
 #ifdef HAVE_ATTR_TEST
 	if (unlikely(test_attr__enabled))
 		test_attr__open(attr, pid, cpu, fd, group_fd, flags);
 #endif
 	return fd;
 }
 #endif /* _PERF_SYS_H */

tools/perf/tests/dwarf-unwind.c

Diff comments View file @ 59b2858

 #include <linux/compiler.h>
 #include <linux/types.h>
 #include <unistd.h>
 #include "tests.h"
 #include "debug.h"
 #include "machine.h"
 #include "event.h"
 #include "unwind.h"
 #include "perf_regs.h"
 #include "map.h"
 #include "thread.h"
 #include "callchain.h"
+/* For bsearch. We try to unwind functions in shared object. */
+#include <stdlib.h>
 static int mmap_handler(struct perf_tool *tool __maybe_unused,
 			union perf_event *event,
 			struct perf_sample *sample __maybe_unused,
 			struct machine *machine)
 {
 	return machine__process_mmap2_event(machine, event, NULL);
 }
 static int init_live_machine(struct machine *machine)
 {
 	union perf_event event;
 	pid_t pid = getpid();
 	return perf_event__synthesize_mmap_events(NULL, &event, pid, pid,
 						  mmap_handler, machine, true);
 }
-#define MAX_STACK 6
+#define MAX_STACK 8
 static int unwind_entry(struct unwind_entry *entry, void *arg)
 {
 	unsigned long *cnt = (unsigned long *) arg;
 	char *symbol = entry->sym ? entry->sym->name : NULL;
 	static const char *funcs[MAX_STACK] = {
 		"test__arch_unwind_sample",
 		"unwind_thread",
+		"compare",
+		"bsearch",
 		"krava_3",
 		"krava_2",
 		"krava_1",
 		"test__dwarf_unwind"
 	};
 	if (*cnt >= MAX_STACK) {
 		pr_debug("failed: crossed the max stack value %d\n", MAX_STACK);
 		return -1;
 	}
 	if (!symbol) {
 		pr_debug("failed: got unresolved address 0x%" PRIx64 "\n",
 			 entry->ip);
 		return -1;
 	}
 	pr_debug("got: %s 0x%" PRIx64 "\n", symbol, entry->ip);
 	return strcmp((const char *) symbol, funcs[(*cnt)++]);
 }
 __attribute__ ((noinline))
 static int unwind_thread(struct thread *thread)
 {
 	struct perf_sample sample;
 	unsigned long cnt = 0;
 	int err = -1;
 	memset(&sample, 0, sizeof(sample));
 	if (test__arch_unwind_sample(&sample, thread)) {
 		pr_debug("failed to get unwind sample\n");
 		goto out;
 	}
 	err = unwind__get_entries(unwind_entry, &cnt, thread,
 				  &sample, MAX_STACK);
 	if (err)
 		pr_debug("unwind failed\n");
 	else if (cnt != MAX_STACK) {
 		pr_debug("got wrong number of stack entries %lu != %d\n",
 			 cnt, MAX_STACK);
 		err = -1;
 	}
  out:
 	free(sample.user_stack.data);
 	free(sample.user_regs.regs);
 	return err;
 }
+static int global_unwind_retval = -INT_MAX;
 __attribute__ ((noinline))
+static int compare(void *p1, void *p2)
+{
+	/* Any possible value should be 'thread' */
+	struct thread *thread = *(struct thread **)p1;
+	if (global_unwind_retval == -INT_MAX)
+		global_unwind_retval = unwind_thread(thread);
+	return p1 - p2;
+}
+__attribute__ ((noinline))
 static int krava_3(struct thread *thread)
 {
-	return unwind_thread(thread);
+	struct thread *array[2] = {thread, thread};
+	void *fp = &bsearch;
+	/*
+	 * make _bsearch a volatile function pointer to
+	 * prevent potential optimization, which may expand
+	 * bsearch and call compare directly from this function,
+	 * instead of libc shared object.
+	 */
+	void *(*volatile _bsearch)(void *, void *, size_t,
+			size_t, int (*)(void *, void *));
+	_bsearch = fp;
+	_bsearch(array, &thread, 2, sizeof(struct thread **), compare);
+	return global_unwind_retval;
 }
 __attribute__ ((noinline))
 static int krava_2(struct thread *thread)
 {
 	return krava_3(thread);
 }
 __attribute__ ((noinline))
 static int krava_1(struct thread *thread)
 {
 	return krava_2(thread);
 }
 int test__dwarf_unwind(void)
 {
 	struct machines machines;
 	struct machine *machine;
 	struct thread *thread;
 	int err = -1;
 	machines__init(&machines);
 	machine = machines__find(&machines, HOST_KERNEL_ID);
 	if (!machine) {
 		pr_err("Could not get machine\n");
 		return -1;
 	}
 	callchain_param.record_mode = CALLCHAIN_DWARF;
 	if (init_live_machine(machine)) {
 		pr_err("Could not init machine\n");
 		goto out;
 	}
 	if (verbose > 1)
 		machine__fprintf(machine, stderr);
 	thread = machine__find_thread(machine, getpid(), getpid());
 	if (!thread) {
 		pr_err("Could not get thread\n");
 		goto out;
 	}
 	err = krava_1(thread);
  out:
 	machine__delete_threads(machine);
 	machine__exit(machine);
 	machines__exit(&machines);
 	return err;
 }

tools/perf/util/annotate.h

Diff comments View file @ 59b2858

 #ifndef __PERF_ANNOTATE_H
 #define __PERF_ANNOTATE_H
 #include <stdbool.h>
 #include <stdint.h>
 #include <linux/types.h>
 #include "symbol.h"
 #include "hist.h"
 #include "sort.h"
 #include <linux/list.h>
 #include <linux/rbtree.h>
 #include <pthread.h>
 struct ins;
 struct ins_operands {
 	char	*raw;
 	struct {
 		char	*raw;
 		char	*name;
 		u64	addr;
 		u64	offset;
 	} target;
 	union {
 		struct {
 			char	*raw;
 			char	*name;
 			u64	addr;
 		} source;
 		struct {
 			struct ins *ins;
 			struct ins_operands *ops;
 		} locked;
 	};
 };
 struct ins_ops {
 	void (*free)(struct ins_operands *ops);
 	int (*parse)(struct ins_operands *ops);
 	int (*scnprintf)(struct ins *ins, char *bf, size_t size,
 			 struct ins_operands *ops);
 };
 struct ins {
 	const char     *name;
 	struct ins_ops *ops;
 };
 bool ins__is_jump(const struct ins *ins);
 bool ins__is_call(const struct ins *ins);
 int ins__scnprintf(struct ins *ins, char *bf, size_t size, struct ins_operands *ops);
 struct annotation;
 struct disasm_line {
 	struct list_head    node;
 	s64		    offset;
 	char		    *line;
 	char		    *name;
 	struct ins	    *ins;
 	int		    line_nr;
 	struct ins_operands ops;
 };
 static inline bool disasm_line__has_offset(const struct disasm_line *dl)
 {
 	return dl->ops.target.offset != UINT64_MAX;
 }
 void disasm_line__free(struct disasm_line *dl);
 struct disasm_line *disasm__get_next_ip_line(struct list_head *head, struct disasm_line *pos);
 int disasm_line__scnprintf(struct disasm_line *dl, char *bf, size_t size, bool raw);
 size_t disasm__fprintf(struct list_head *head, FILE *fp);
 double disasm__calc_percent(struct annotation *notes, int evidx, s64 offset,
 			    s64 end, const char **path);
 struct sym_hist {
 	u64		sum;
 	u64		addr[0];
 };
 struct source_line_percent {
 	double		percent;
 	double		percent_sum;
 };
 struct source_line {
 	struct rb_node	node;
 	char		*path;
 	int		nr_pcnt;
 	struct source_line_percent p[1];
 };
 /** struct annotated_source - symbols with hits have this attached as in sannotation
  *
  * @histogram: Array of addr hit histograms per event being monitored
  * @lines: If 'print_lines' is specified, per source code line percentages
  * @source: source parsed from a disassembler like objdump -dS
  *
  * lines is allocated, percentages calculated and all sorted by percentage
  * when the annotation is about to be presented, so the percentages are for
  * one of the entries in the histogram array, i.e. for the event/counter being
  * presented. It is deallocated right after symbol__{tui,tty,etc}_annotate
  * returns.
  */
 struct annotated_source {
 	struct list_head   source;
 	struct source_line *lines;
 	int    		   nr_histograms;
 	int    		   sizeof_sym_hist;
 	struct sym_hist	   histograms[0];
 };
 struct annotation {
 	pthread_mutex_t		lock;
 	struct annotated_source *src;
 };
-struct sannotation {
-	struct annotation annotation;
-	struct symbol	  symbol;
-};
 static inline struct sym_hist *annotation__histogram(struct annotation *notes, int idx)
 {
 	return (((void *)&notes->src->histograms) +
 	 	(notes->src->sizeof_sym_hist * idx));
 }
 static inline struct annotation *symbol__annotation(struct symbol *sym)
 {
-	struct sannotation *a = container_of(sym, struct sannotation, symbol);
+	return (void *)sym - symbol_conf.priv_size;
-	return &a->annotation;
 }
 int addr_map_symbol__inc_samples(struct addr_map_symbol *ams, int evidx);
 int hist_entry__inc_addr_samples(struct hist_entry *he, int evidx, u64 addr);
 int symbol__alloc_hist(struct symbol *sym);
 void symbol__annotate_zero_histograms(struct symbol *sym);
 int symbol__annotate(struct symbol *sym, struct map *map, size_t privsize);
 int hist_entry__annotate(struct hist_entry *he, size_t privsize);
 int symbol__annotate_init(struct map *map __maybe_unused, struct symbol *sym);
 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);
 void symbol__annotate_zero_histogram(struct symbol *sym, int evidx);
 void symbol__annotate_decay_histogram(struct symbol *sym, int evidx);
 void disasm__purge(struct list_head *head);
 bool ui__has_annotation(void);
 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);
 #ifdef HAVE_SLANG_SUPPORT
 int symbol__tui_annotate(struct symbol *sym, struct map *map,
 			 struct perf_evsel *evsel,
 			 struct hist_browser_timer *hbt);
 #else
 static inline int symbol__tui_annotate(struct symbol *sym __maybe_unused,
 				struct map *map __maybe_unused,
 				struct perf_evsel *evsel  __maybe_unused,
 				struct hist_browser_timer *hbt
 				__maybe_unused)
 {
 	return 0;
 }
 #endif
 extern const char	*disassembler_style;
 #endif	/* __PERF_ANNOTATE_H */

tools/perf/util/cache.h

Diff comments View file @ 59b2858

 #ifndef __PERF_CACHE_H
 #define __PERF_CACHE_H
 #include <stdbool.h>
 #include "util.h"
 #include "strbuf.h"
 #include "../perf.h"
 #include "../ui/ui.h"
 #define CMD_EXEC_PATH "--exec-path"
 #define CMD_PERF_DIR "--perf-dir="
 #define CMD_WORK_TREE "--work-tree="
 #define CMD_DEBUGFS_DIR "--debugfs-dir="
 #define PERF_DIR_ENVIRONMENT "PERF_DIR"
 #define PERF_WORK_TREE_ENVIRONMENT "PERF_WORK_TREE"
 #define EXEC_PATH_ENVIRONMENT "PERF_EXEC_PATH"
 #define DEFAULT_PERF_DIR_ENVIRONMENT ".perf"
 #define PERF_DEBUGFS_ENVIRONMENT "PERF_DEBUGFS_DIR"
 typedef int (*config_fn_t)(const char *, const char *, void *);
 extern int perf_default_config(const char *, const char *, void *);
 extern int perf_config(config_fn_t fn, void *);
 extern int perf_config_int(const char *, const char *);
 extern u64 perf_config_u64(const char *, const char *);
 extern int perf_config_bool(const char *, const char *);
 extern int config_error_nonbool(const char *);
 extern const char *perf_config_dirname(const char *, const char *);
 /* pager.c */
 extern void setup_pager(void);
 extern const char *pager_program;
 extern int pager_in_use(void);
 extern int pager_use_color;
 char *alias_lookup(const char *alias);
 int split_cmdline(char *cmdline, const char ***argv);
 #define alloc_nr(x) (((x)+16)*3/2)
 /*
  * Realloc the buffer pointed at by variable 'x' so that it can hold
  * at least 'nr' entries; the number of entries currently allocated
  * is 'alloc', using the standard growing factor alloc_nr() macro.
  *
  * DO NOT USE any expression with side-effect for 'x' or 'alloc'.
  */
 #define ALLOC_GROW(x, nr, alloc) \
 	do { \
 		if ((nr) > alloc) { \
 			if (alloc_nr(alloc) < (nr)) \
 				alloc = (nr); \
 			else \
 				alloc = alloc_nr(alloc); \
 			x = xrealloc((x), alloc * sizeof(*(x))); \
 		} \
 	} while(0)
 static inline int is_absolute_path(const char *path)
 {
 	return path[0] == '/';
 }
 const char *make_nonrelative_path(const char *path);
 char *strip_path_suffix(const char *path, const char *suffix);
 extern char *mkpath(const char *fmt, ...) __attribute__((format (printf, 1, 2)));
 extern char *perf_path(const char *fmt, ...) __attribute__((format (printf, 1, 2)));
 extern char *perf_pathdup(const char *fmt, ...)
 	__attribute__((format (printf, 1, 2)));
+#ifndef __UCLIBC__
 /* Matches the libc/libbsd function attribute so we declare this unconditionally: */
 extern size_t strlcpy(char *dest, const char *src, size_t size);
+#endif
 #endif /* __PERF_CACHE_H */

tools/perf/util/hweight.c

View file @ 59b2858

1	#include <linux/bitops.h>		File was deleted
2
3	/**
4	* hweightN - returns the hamming weight of a N-bit word
5	* @x: the word to weigh
6	*
7	* The Hamming Weight of a number is the total number of bits set in it.
8	*/
9
10	unsigned int hweight32(unsigned int w)
11	{
12	unsigned int res = w - ((w >> 1) & 0x55555555);
13	res = (res & 0x33333333) + ((res >> 2) & 0x33333333);
14	res = (res + (res >> 4)) & 0x0F0F0F0F;
15	res = res + (res >> 8);
16	return (res + (res >> 16)) & 0x000000FF;
17	}
18
19	unsigned long hweight64(__u64 w)
20	{
21	#if BITS_PER_LONG == 32
22	return hweight32((unsigned int)(w >> 32)) + hweight32((unsigned int)w);
23	#elif BITS_PER_LONG == 64
24	__u64 res = w - ((w >> 1) & 0x5555555555555555ul);
25	res = (res & 0x3333333333333333ul) + ((res >> 2) & 0x3333333333333333ul);
26	res = (res + (res >> 4)) & 0x0F0F0F0F0F0F0F0Ful;
27	res = res + (res >> 8);
28	res = res + (res >> 16);
29	return (res + (res >> 32)) & 0x00000000000000FFul;
30	#endif
31	}
32		1	#include <linux/bitops.h>

tools/perf/util/include/asm/hweight.h

View file @ 59b2858

1	#ifndef PERF_HWEIGHT_H		File was deleted
2	#define PERF_HWEIGHT_H
3
4	#include <linux/types.h>
5	unsigned int hweight32(unsigned int w);
6	unsigned long hweight64(__u64 w);
7
8	#endif /* PERF_HWEIGHT_H */
9		1	#ifndef PERF_HWEIGHT_H

tools/perf/util/machine.c

Diff comments View file @ 59b2858

 #include "callchain.h"
 #include "debug.h"
 #include "event.h"
 #include "evsel.h"
 #include "hist.h"
 #include "machine.h"
 #include "map.h"
 #include "sort.h"
 #include "strlist.h"
 #include "thread.h"
 #include "vdso.h"
 #include <stdbool.h>
 #include <symbol/kallsyms.h>
 #include "unwind.h"
 #include "linux/hash.h"
 static void dsos__init(struct dsos *dsos)
 {
 	INIT_LIST_HEAD(&dsos->head);
 	dsos->root = RB_ROOT;
 }
 int machine__init(struct machine *machine, const char *root_dir, pid_t pid)
 {
 	map_groups__init(&machine->kmaps, machine);
 	RB_CLEAR_NODE(&machine->rb_node);
 	dsos__init(&machine->user_dsos);
 	dsos__init(&machine->kernel_dsos);
 	machine->threads = RB_ROOT;
 	INIT_LIST_HEAD(&machine->dead_threads);
 	machine->last_match = NULL;
 	machine->vdso_info = NULL;
 	machine->pid = pid;
 	machine->symbol_filter = NULL;
 	machine->id_hdr_size = 0;
 	machine->comm_exec = false;
 	machine->kernel_start = 0;
 	machine->root_dir = strdup(root_dir);
 	if (machine->root_dir == NULL)
 		return -ENOMEM;
 	if (pid != HOST_KERNEL_ID) {
 		struct thread *thread = machine__findnew_thread(machine, -1,
 								pid);
 		char comm[64];
 		if (thread == NULL)
 			return -ENOMEM;
 		snprintf(comm, sizeof(comm), "[guest/%d]", pid);
 		thread__set_comm(thread, comm, 0);
 	}
 	machine->current_tid = NULL;
 	return 0;
 }
 struct machine *machine__new_host(void)
 {
 	struct machine *machine = malloc(sizeof(*machine));
 	if (machine != NULL) {
 		machine__init(machine, "", HOST_KERNEL_ID);
 		if (machine__create_kernel_maps(machine) < 0)
 			goto out_delete;
 	}
 	return machine;
 out_delete:
 	free(machine);
 	return NULL;
 }
 static void dsos__delete(struct dsos *dsos)
 {
 	struct dso *pos, *n;
 	list_for_each_entry_safe(pos, n, &dsos->head, node) {
 		RB_CLEAR_NODE(&pos->rb_node);
 		list_del(&pos->node);
 		dso__delete(pos);
 	}
 }
 void machine__delete_dead_threads(struct machine *machine)
 {
 	struct thread *n, *t;
 	list_for_each_entry_safe(t, n, &machine->dead_threads, node) {
 		list_del(&t->node);
 		thread__delete(t);
 	}
 }
 void machine__delete_threads(struct machine *machine)
 {
 	struct rb_node *nd = rb_first(&machine->threads);
 	while (nd) {
 		struct thread *t = rb_entry(nd, struct thread, rb_node);
 		rb_erase(&t->rb_node, &machine->threads);
 		nd = rb_next(nd);
 		thread__delete(t);
 	}
 }
 void machine__exit(struct machine *machine)
 {
 	map_groups__exit(&machine->kmaps);
 	dsos__delete(&machine->user_dsos);
 	dsos__delete(&machine->kernel_dsos);
 	vdso__exit(machine);
 	zfree(&machine->root_dir);
 	zfree(&machine->current_tid);
 }
 void machine__delete(struct machine *machine)
 {
 	machine__exit(machine);
 	free(machine);
 }
 void machines__init(struct machines *machines)
 {
 	machine__init(&machines->host, "", HOST_KERNEL_ID);
 	machines->guests = RB_ROOT;
 	machines->symbol_filter = NULL;
 }
 void machines__exit(struct machines *machines)
 {
 	machine__exit(&machines->host);
 	/* XXX exit guest */
 }
 struct machine *machines__add(struct machines *machines, pid_t pid,
 			      const char *root_dir)
 {
 	struct rb_node **p = &machines->guests.rb_node;
 	struct rb_node *parent = NULL;
 	struct machine *pos, *machine = malloc(sizeof(*machine));
 	if (machine == NULL)
 		return NULL;
 	if (machine__init(machine, root_dir, pid) != 0) {
 		free(machine);
 		return NULL;
 	}
 	machine->symbol_filter = machines->symbol_filter;
 	while (*p != NULL) {
 		parent = *p;
 		pos = rb_entry(parent, struct machine, rb_node);
 		if (pid < pos->pid)
 			p = &(*p)->rb_left;
 		else
 			p = &(*p)->rb_right;
 	}
 	rb_link_node(&machine->rb_node, parent, p);
 	rb_insert_color(&machine->rb_node, &machines->guests);
 	return machine;
 }
 void machines__set_symbol_filter(struct machines *machines,
 				 symbol_filter_t symbol_filter)
 {
 	struct rb_node *nd;
 	machines->symbol_filter = symbol_filter;
 	machines->host.symbol_filter = symbol_filter;
 	for (nd = rb_first(&machines->guests); nd; nd = rb_next(nd)) {
 		struct machine *machine = rb_entry(nd, struct machine, rb_node);
 		machine->symbol_filter = symbol_filter;
 	}
 }
 void machines__set_comm_exec(struct machines *machines, bool comm_exec)
 {
 	struct rb_node *nd;
 	machines->host.comm_exec = comm_exec;
 	for (nd = rb_first(&machines->guests); nd; nd = rb_next(nd)) {
 		struct machine *machine = rb_entry(nd, struct machine, rb_node);
 		machine->comm_exec = comm_exec;
 	}
 }
 struct machine *machines__find(struct machines *machines, pid_t pid)
 {
 	struct rb_node **p = &machines->guests.rb_node;
 	struct rb_node *parent = NULL;
 	struct machine *machine;
 	struct machine *default_machine = NULL;
 	if (pid == HOST_KERNEL_ID)
 		return &machines->host;
 	while (*p != NULL) {
 		parent = *p;
 		machine = rb_entry(parent, struct machine, rb_node);
 		if (pid < machine->pid)
 			p = &(*p)->rb_left;
 		else if (pid > machine->pid)
 			p = &(*p)->rb_right;
 		else
 			return machine;
 		if (!machine->pid)
 			default_machine = machine;
 	}
 	return default_machine;
 }
 struct machine *machines__findnew(struct machines *machines, pid_t pid)
 {
 	char path[PATH_MAX];
 	const char *root_dir = "";
 	struct machine *machine = machines__find(machines, pid);
 	if (machine && (machine->pid == pid))
 		goto out;
 	if ((pid != HOST_KERNEL_ID) &&
 	    (pid != DEFAULT_GUEST_KERNEL_ID) &&
 	    (symbol_conf.guestmount)) {
 		sprintf(path, "%s/%d", symbol_conf.guestmount, pid);
 		if (access(path, R_OK)) {
 			static struct strlist *seen;
 			if (!seen)
 				seen = strlist__new(true, NULL);
 			if (!strlist__has_entry(seen, path)) {
 				pr_err("Can't access file %s\n", path);
 				strlist__add(seen, path);
 			}
 			machine = NULL;
 			goto out;
 		}
 		root_dir = path;
 	}
 	machine = machines__add(machines, pid, root_dir);
 out:
 	return machine;
 }
 void machines__process_guests(struct machines *machines,
 			      machine__process_t process, void *data)
 {
 	struct rb_node *nd;
 	for (nd = rb_first(&machines->guests); nd; nd = rb_next(nd)) {
 		struct machine *pos = rb_entry(nd, struct machine, rb_node);
 		process(pos, data);
 	}
 }
 char *machine__mmap_name(struct machine *machine, char *bf, size_t size)
 {
 	if (machine__is_host(machine))
 		snprintf(bf, size, "[%s]", "kernel.kallsyms");
 	else if (machine__is_default_guest(machine))
 		snprintf(bf, size, "[%s]", "guest.kernel.kallsyms");
 	else {
 		snprintf(bf, size, "[%s.%d]", "guest.kernel.kallsyms",
 			 machine->pid);
 	}
 	return bf;
 }
 void machines__set_id_hdr_size(struct machines *machines, u16 id_hdr_size)
 {
 	struct rb_node *node;
 	struct machine *machine;
 	machines->host.id_hdr_size = id_hdr_size;
 	for (node = rb_first(&machines->guests); node; node = rb_next(node)) {
 		machine = rb_entry(node, struct machine, rb_node);
 		machine->id_hdr_size = id_hdr_size;
 	}
 	return;
 }
 static void machine__update_thread_pid(struct machine *machine,
 				       struct thread *th, pid_t pid)
 {
 	struct thread *leader;
 	if (pid == th->pid_ || pid == -1 || th->pid_ != -1)
 		return;
 	th->pid_ = pid;
 	if (th->pid_ == th->tid)
 		return;
 	leader = machine__findnew_thread(machine, th->pid_, th->pid_);
 	if (!leader)
 		goto out_err;
 	if (!leader->mg)
 		leader->mg = map_groups__new(machine);
 	if (!leader->mg)
 		goto out_err;
 	if (th->mg == leader->mg)
 		return;
 	if (th->mg) {
 		/*
 		 * Maps are created from MMAP events which provide the pid and
 		 * tid.  Consequently there never should be any maps on a thread
 		 * with an unknown pid.  Just print an error if there are.
 		 */
 		if (!map_groups__empty(th->mg))
 			pr_err("Discarding thread maps for %d:%d\n",
 			       th->pid_, th->tid);
 		map_groups__delete(th->mg);
 	}
 	th->mg = map_groups__get(leader->mg);
 	return;
 out_err:
 	pr_err("Failed to join map groups for %d:%d\n", th->pid_, th->tid);
 }
 static struct thread *__machine__findnew_thread(struct machine *machine,
 						pid_t pid, pid_t tid,
 						bool create)
 {
 	struct rb_node **p = &machine->threads.rb_node;
 	struct rb_node *parent = NULL;
 	struct thread *th;
 	/*
 	 * Front-end cache - TID lookups come in blocks,
 	 * so most of the time we dont have to look up
 	 * the full rbtree:
 	 */
 	th = machine->last_match;
 	if (th && th->tid == tid) {
 		machine__update_thread_pid(machine, th, pid);
 		return th;
 	}
 	while (*p != NULL) {
 		parent = *p;
 		th = rb_entry(parent, struct thread, rb_node);
 		if (th->tid == tid) {
 			machine->last_match = th;
 			machine__update_thread_pid(machine, th, pid);
 			return th;
 		}
 		if (tid < th->tid)
 			p = &(*p)->rb_left;
 		else
 			p = &(*p)->rb_right;
 	}
 	if (!create)
 		return NULL;
 	th = thread__new(pid, tid);
 	if (th != NULL) {
 		rb_link_node(&th->rb_node, parent, p);
 		rb_insert_color(&th->rb_node, &machine->threads);
-		machine->last_match = th;
 		/*
 		 * We have to initialize map_groups separately
 		 * after rb tree is updated.
 		 *
 		 * The reason is that we call machine__findnew_thread
 		 * within thread__init_map_groups to find the thread
 		 * leader and that would screwed the rb tree.
 		 */
 		if (thread__init_map_groups(th, machine)) {
+			rb_erase(&th->rb_node, &machine->threads);
 			thread__delete(th);
 			return NULL;
 		}
+		machine->last_match = th;
 	}
 	return th;
 }
 struct thread *machine__findnew_thread(struct machine *machine, pid_t pid,
 				       pid_t tid)
 {
 	return __machine__findnew_thread(machine, pid, tid, true);
 }
 struct thread *machine__find_thread(struct machine *machine, pid_t pid,
 				    pid_t tid)
 {
 	return __machine__findnew_thread(machine, pid, tid, false);
 }
 struct comm *machine__thread_exec_comm(struct machine *machine,
 				       struct thread *thread)
 {
 	if (machine->comm_exec)
 		return thread__exec_comm(thread);
 	else
 		return thread__comm(thread);
 }
 int machine__process_comm_event(struct machine *machine, union perf_event *event,
 				struct perf_sample *sample)
 {
 	struct thread *thread = machine__findnew_thread(machine,
 							event->comm.pid,
 							event->comm.tid);
 	bool exec = event->header.misc & PERF_RECORD_MISC_COMM_EXEC;
 	if (exec)
 		machine->comm_exec = true;
 	if (dump_trace)
 		perf_event__fprintf_comm(event, stdout);
 	if (thread == NULL ||
 	    __thread__set_comm(thread, event->comm.comm, sample->time, exec)) {
 		dump_printf("problem processing PERF_RECORD_COMM, skipping event.\n");
 		return -1;
 	}
 	return 0;
 }
 int machine__process_lost_event(struct machine *machine __maybe_unused,
 				union perf_event *event, struct perf_sample *sample __maybe_unused)
 {
 	dump_printf(": id:%" PRIu64 ": lost:%" PRIu64 "\n",
 		    event->lost.id, event->lost.lost);
 	return 0;
 }
 struct map *machine__new_module(struct machine *machine, u64 start,
 				const char *filename)
 {
 	struct map *map;
 	struct dso *dso = __dsos__findnew(&machine->kernel_dsos, filename);
 	bool compressed;
 	if (dso == NULL)
 		return NULL;
 	map = map__new2(start, dso, MAP__FUNCTION);
 	if (map == NULL)
 		return NULL;
 	if (machine__is_host(machine))
 		dso->symtab_type = DSO_BINARY_TYPE__SYSTEM_PATH_KMODULE;
 	else
 		dso->symtab_type = DSO_BINARY_TYPE__GUEST_KMODULE;
 	/* _KMODULE_COMP should be next to _KMODULE */
 	if (is_kernel_module(filename, &compressed) && compressed)
 		dso->symtab_type++;
 	map_groups__insert(&machine->kmaps, map);
 	return map;
 }
 size_t machines__fprintf_dsos(struct machines *machines, FILE *fp)
 {
 	struct rb_node *nd;
 	size_t ret = __dsos__fprintf(&machines->host.kernel_dsos.head, fp) +
 		     __dsos__fprintf(&machines->host.user_dsos.head, fp);
 	for (nd = rb_first(&machines->guests); nd; nd = rb_next(nd)) {
 		struct machine *pos = rb_entry(nd, struct machine, rb_node);
 		ret += __dsos__fprintf(&pos->kernel_dsos.head, fp);
 		ret += __dsos__fprintf(&pos->user_dsos.head, fp);
 	}
 	return ret;
 }
 size_t machine__fprintf_dsos_buildid(struct machine *m, FILE *fp,
 				     bool (skip)(struct dso *dso, int parm), int parm)
 {
 	return __dsos__fprintf_buildid(&m->kernel_dsos.head, fp, skip, parm) +
 	       __dsos__fprintf_buildid(&m->user_dsos.head, fp, skip, parm);
 }
 size_t machines__fprintf_dsos_buildid(struct machines *machines, FILE *fp,
 				     bool (skip)(struct dso *dso, int parm), int parm)
 {
 	struct rb_node *nd;
 	size_t ret = machine__fprintf_dsos_buildid(&machines->host, fp, skip, parm);
 	for (nd = rb_first(&machines->guests); nd; nd = rb_next(nd)) {
 		struct machine *pos = rb_entry(nd, struct machine, rb_node);
 		ret += machine__fprintf_dsos_buildid(pos, fp, skip, parm);
 	}
 	return ret;
 }
 size_t machine__fprintf_vmlinux_path(struct machine *machine, FILE *fp)
 {
 	int i;
 	size_t printed = 0;
 	struct dso *kdso = machine->vmlinux_maps[MAP__FUNCTION]->dso;
 	if (kdso->has_build_id) {
 		char filename[PATH_MAX];
 		if (dso__build_id_filename(kdso, filename, sizeof(filename)))
 			printed += fprintf(fp, "[0] %s\n", filename);
 	}
 	for (i = 0; i < vmlinux_path__nr_entries; ++i)
 		printed += fprintf(fp, "[%d] %s\n",
 				   i + kdso->has_build_id, vmlinux_path[i]);
 	return printed;
 }
 size_t machine__fprintf(struct machine *machine, FILE *fp)
 {
 	size_t ret = 0;
 	struct rb_node *nd;
 	for (nd = rb_first(&machine->threads); nd; nd = rb_next(nd)) {
 		struct thread *pos = rb_entry(nd, struct thread, rb_node);
 		ret += thread__fprintf(pos, fp);
 	}
 	return ret;
 }
 static struct dso *machine__get_kernel(struct machine *machine)
 {
 	const char *vmlinux_name = NULL;
 	struct dso *kernel;
 	if (machine__is_host(machine)) {
 		vmlinux_name = symbol_conf.vmlinux_name;
 		if (!vmlinux_name)
 			vmlinux_name = "[kernel.kallsyms]";
 		kernel = dso__kernel_findnew(machine, vmlinux_name,
 					     "[kernel]",
 					     DSO_TYPE_KERNEL);
 	} else {
 		char bf[PATH_MAX];
 		if (machine__is_default_guest(machine))
 			vmlinux_name = symbol_conf.default_guest_vmlinux_name;
 		if (!vmlinux_name)
 			vmlinux_name = machine__mmap_name(machine, bf,
 							  sizeof(bf));
 		kernel = dso__kernel_findnew(machine, vmlinux_name,
 					     "[guest.kernel]",
 					     DSO_TYPE_GUEST_KERNEL);
 	}
 	if (kernel != NULL && (!kernel->has_build_id))
 		dso__read_running_kernel_build_id(kernel, machine);
 	return kernel;
 }
 struct process_args {
 	u64 start;
 };
 static void machine__get_kallsyms_filename(struct machine *machine, char *buf,
 					   size_t bufsz)
 {
 	if (machine__is_default_guest(machine))
 		scnprintf(buf, bufsz, "%s", symbol_conf.default_guest_kallsyms);
 	else
 		scnprintf(buf, bufsz, "%s/proc/kallsyms", machine->root_dir);
 }
 const char *ref_reloc_sym_names[] = {"_text", "_stext", NULL};
 /* Figure out the start address of kernel map from /proc/kallsyms.
  * Returns the name of the start symbol in *symbol_name. Pass in NULL as
  * symbol_name if it's not that important.
  */
 static u64 machine__get_running_kernel_start(struct machine *machine,
 					     const char **symbol_name)
 {
 	char filename[PATH_MAX];
 	int i;
 	const char *name;
 	u64 addr = 0;
 	machine__get_kallsyms_filename(machine, filename, PATH_MAX);
 	if (symbol__restricted_filename(filename, "/proc/kallsyms"))
 		return 0;
 	for (i = 0; (name = ref_reloc_sym_names[i]) != NULL; i++) {
 		addr = kallsyms__get_function_start(filename, name);
 		if (addr)
 			break;
 	}
 	if (symbol_name)
 		*symbol_name = name;
 	return addr;
 }
 int __machine__create_kernel_maps(struct machine *machine, struct dso *kernel)
 {
 	enum map_type type;
 	u64 start = machine__get_running_kernel_start(machine, NULL);
 	for (type = 0; type < MAP__NR_TYPES; ++type) {
 		struct kmap *kmap;
 		machine->vmlinux_maps[type] = map__new2(start, kernel, type);
 		if (machine->vmlinux_maps[type] == NULL)
 			return -1;
 		machine->vmlinux_maps[type]->map_ip =
 			machine->vmlinux_maps[type]->unmap_ip =
 				identity__map_ip;
 		kmap = map__kmap(machine->vmlinux_maps[type]);
 		kmap->kmaps = &machine->kmaps;
 		map_groups__insert(&machine->kmaps,
 				   machine->vmlinux_maps[type]);
 	}
 	return 0;
 }
 void machine__destroy_kernel_maps(struct machine *machine)
 {
 	enum map_type type;
 	for (type = 0; type < MAP__NR_TYPES; ++type) {
 		struct kmap *kmap;
 		if (machine->vmlinux_maps[type] == NULL)
 			continue;
 		kmap = map__kmap(machine->vmlinux_maps[type]);
 		map_groups__remove(&machine->kmaps,
 				   machine->vmlinux_maps[type]);
 		if (kmap->ref_reloc_sym) {
 			/*
 			 * ref_reloc_sym is shared among all maps, so free just
 			 * on one of them.
 			 */
 			if (type == MAP__FUNCTION) {
 				zfree((char **)&kmap->ref_reloc_sym->name);
 				zfree(&kmap->ref_reloc_sym);
 			} else
 				kmap->ref_reloc_sym = NULL;
 		}
 		map__delete(machine->vmlinux_maps[type]);
 		machine->vmlinux_maps[type] = NULL;
 	}
 }
 int machines__create_guest_kernel_maps(struct machines *machines)
 {
 	int ret = 0;
 	struct dirent **namelist = NULL;
 	int i, items = 0;
 	char path[PATH_MAX];
 	pid_t pid;
 	char *endp;
 	if (symbol_conf.default_guest_vmlinux_name ||
 	    symbol_conf.default_guest_modules ||
 	    symbol_conf.default_guest_kallsyms) {
 		machines__create_kernel_maps(machines, DEFAULT_GUEST_KERNEL_ID);
 	}
 	if (symbol_conf.guestmount) {
 		items = scandir(symbol_conf.guestmount, &namelist, NULL, NULL);
 		if (items <= 0)
 			return -ENOENT;
 		for (i = 0; i < items; i++) {
 			if (!isdigit(namelist[i]->d_name[0])) {
 				/* Filter out . and .. */
 				continue;
 			}
 			pid = (pid_t)strtol(namelist[i]->d_name, &endp, 10);
 			if ((*endp != '\0') ||
 			    (endp == namelist[i]->d_name) ||
 			    (errno == ERANGE)) {
 				pr_debug("invalid directory (%s). Skipping.\n",
 					 namelist[i]->d_name);
 				continue;
 			}
 			sprintf(path, "%s/%s/proc/kallsyms",
 				symbol_conf.guestmount,
 				namelist[i]->d_name);
 			ret = access(path, R_OK);
 			if (ret) {
 				pr_debug("Can't access file %s\n", path);
 				goto failure;
 			}
 			machines__create_kernel_maps(machines, pid);
 		}
 failure:
 		free(namelist);
 	}
 	return ret;
 }
 void machines__destroy_kernel_maps(struct machines *machines)
 {
 	struct rb_node *next = rb_first(&machines->guests);
 	machine__destroy_kernel_maps(&machines->host);
 	while (next) {
 		struct machine *pos = rb_entry(next, struct machine, rb_node);
 		next = rb_next(&pos->rb_node);
 		rb_erase(&pos->rb_node, &machines->guests);
 		machine__delete(pos);
 	}
 }
 int machines__create_kernel_maps(struct machines *machines, pid_t pid)
 {
 	struct machine *machine = machines__findnew(machines, pid);
 	if (machine == NULL)
 		return -1;
 	return machine__create_kernel_maps(machine);
 }
 int machine__load_kallsyms(struct machine *machine, const char *filename,
 			   enum map_type type, symbol_filter_t filter)
 {
 	struct map *map = machine->vmlinux_maps[type];
 	int ret = dso__load_kallsyms(map->dso, filename, map, filter);
 	if (ret > 0) {
 		dso__set_loaded(map->dso, type);
 		/*
 		 * Since /proc/kallsyms will have multiple sessions for the
 		 * kernel, with modules between them, fixup the end of all
 		 * sections.
 		 */
 		__map_groups__fixup_end(&machine->kmaps, type);
 	}
 	return ret;
 }
 int machine__load_vmlinux_path(struct machine *machine, enum map_type type,
 			       symbol_filter_t filter)
 {
 	struct map *map = machine->vmlinux_maps[type];
 	int ret = dso__load_vmlinux_path(map->dso, map, filter);
 	if (ret > 0)
 		dso__set_loaded(map->dso, type);
 	return ret;
 }
 static void map_groups__fixup_end(struct map_groups *mg)
 {
 	int i;
 	for (i = 0; i < MAP__NR_TYPES; ++i)
 		__map_groups__fixup_end(mg, i);
 }
 static char *get_kernel_version(const char *root_dir)
 {
 	char version[PATH_MAX];
 	FILE *file;
 	char *name, *tmp;
 	const char *prefix = "Linux version ";
 	sprintf(version, "%s/proc/version", root_dir);
 	file = fopen(version, "r");
 	if (!file)
 		return NULL;
 	version[0] = '\0';
 	tmp = fgets(version, sizeof(version), file);
 	fclose(file);
 	name = strstr(version, prefix);
 	if (!name)
 		return NULL;
 	name += strlen(prefix);
 	tmp = strchr(name, ' ');
 	if (tmp)
 		*tmp = '\0';
 	return strdup(name);
 }
 static int map_groups__set_modules_path_dir(struct map_groups *mg,
 				const char *dir_name, int depth)
 {
 	struct dirent *dent;
 	DIR *dir = opendir(dir_name);
 	int ret = 0;
 	if (!dir) {
 		pr_debug("%s: cannot open %s dir\n", __func__, dir_name);
 		return -1;
 	}
 	while ((dent = readdir(dir)) != NULL) {
 		char path[PATH_MAX];
 		struct stat st;
 		/*sshfs might return bad dent->d_type, so we have to stat*/
 		snprintf(path, sizeof(path), "%s/%s", dir_name, dent->d_name);
 		if (stat(path, &st))
 			continue;
 		if (S_ISDIR(st.st_mode)) {
 			if (!strcmp(dent->d_name, ".") ||
 			    !strcmp(dent->d_name, ".."))
 				continue;
 			/* Do not follow top-level source and build symlinks */
 			if (depth == 0) {
 				if (!strcmp(dent->d_name, "source") ||
 				    !strcmp(dent->d_name, "build"))
 					continue;
 			}
 			ret = map_groups__set_modules_path_dir(mg, path,
 							       depth + 1);
 			if (ret < 0)
 				goto out;
 		} else {
 			char *dot = strrchr(dent->d_name, '.'),
 			     dso_name[PATH_MAX];
 			struct map *map;
 			char *long_name;
 			if (dot == NULL)
 				continue;
 			/* On some system, modules are compressed like .ko.gz */
 			if (is_supported_compression(dot + 1) &&
 			    is_kmodule_extension(dot - 2))
 				dot -= 3;
 			snprintf(dso_name, sizeof(dso_name), "[%.*s]",
 				 (int)(dot - dent->d_name), dent->d_name);
 			strxfrchar(dso_name, '-', '_');
 			map = map_groups__find_by_name(mg, MAP__FUNCTION,
 						       dso_name);
 			if (map == NULL)
 				continue;
 			long_name = strdup(path);
 			if (long_name == NULL) {
 				ret = -1;
 				goto out;
 			}
 			dso__set_long_name(map->dso, long_name, true);
 			dso__kernel_module_get_build_id(map->dso, "");
 		}
 	}
 out:
 	closedir(dir);
 	return ret;
 }
 static int machine__set_modules_path(struct machine *machine)
 {
 	char *version;
 	char modules_path[PATH_MAX];
 	version = get_kernel_version(machine->root_dir);
 	if (!version)
 		return -1;
 	snprintf(modules_path, sizeof(modules_path), "%s/lib/modules/%s",
 		 machine->root_dir, version);
 	free(version);
 	return map_groups__set_modules_path_dir(&machine->kmaps, modules_path, 0);
 }
 static int machine__create_module(void *arg, const char *name, u64 start)
 {
 	struct machine *machine = arg;
 	struct map *map;
 	map = machine__new_module(machine, start, name);
 	if (map == NULL)
 		return -1;
 	dso__kernel_module_get_build_id(map->dso, machine->root_dir);
 	return 0;
 }
 static int machine__create_modules(struct machine *machine)
 {
 	const char *modules;
 	char path[PATH_MAX];
 	if (machine__is_default_guest(machine)) {
 		modules = symbol_conf.default_guest_modules;
 	} else {
 		snprintf(path, PATH_MAX, "%s/proc/modules", machine->root_dir);
 		modules = path;
 	}
 	if (symbol__restricted_filename(modules, "/proc/modules"))
 		return -1;
 	if (modules__parse(modules, machine, machine__create_module))
 		return -1;
 	if (!machine__set_modules_path(machine))
 		return 0;
 	pr_debug("Problems setting modules path maps, continuing anyway...\n");
 	return 0;
 }
 int machine__create_kernel_maps(struct machine *machine)
 {
 	struct dso *kernel = machine__get_kernel(machine);
 	const char *name;
 	u64 addr = machine__get_running_kernel_start(machine, &name);
 	if (!addr)
 		return -1;
 	if (kernel == NULL ||
 	    __machine__create_kernel_maps(machine, kernel) < 0)
 		return -1;
 	if (symbol_conf.use_modules && machine__create_modules(machine) < 0) {
 		if (machine__is_host(machine))
 			pr_debug("Problems creating module maps, "
 				 "continuing anyway...\n");
 		else
 			pr_debug("Problems creating module maps for guest %d, "
 				 "continuing anyway...\n", machine->pid);
 	}
 	/*
 	 * Now that we have all the maps created, just set the ->end of them:
 	 */
 	map_groups__fixup_end(&machine->kmaps);
 	if (maps__set_kallsyms_ref_reloc_sym(machine->vmlinux_maps, name,
 					     addr)) {
 		machine__destroy_kernel_maps(machine);
 		return -1;
 	}
 	return 0;
 }
 static void machine__set_kernel_mmap_len(struct machine *machine,
 					 union perf_event *event)
 {
 	int i;
 	for (i = 0; i < MAP__NR_TYPES; i++) {
 		machine->vmlinux_maps[i]->start = event->mmap.start;
 		machine->vmlinux_maps[i]->end   = (event->mmap.start +
 						   event->mmap.len);
 		/*
 		 * Be a bit paranoid here, some perf.data file came with
 		 * a zero sized synthesized MMAP event for the kernel.
 		 */
 		if (machine->vmlinux_maps[i]->end == 0)
 			machine->vmlinux_maps[i]->end = ~0ULL;
 	}
 }
 static bool machine__uses_kcore(struct machine *machine)
 {
 	struct dso *dso;
 	list_for_each_entry(dso, &machine->kernel_dsos.head, node) {
 		if (dso__is_kcore(dso))
 			return true;
 	}
 	return false;
 }
 static int machine__process_kernel_mmap_event(struct machine *machine,
 					      union perf_event *event)
 {
 	struct map *map;
 	char kmmap_prefix[PATH_MAX];
 	enum dso_kernel_type kernel_type;
 	bool is_kernel_mmap;
 	/* If we have maps from kcore then we do not need or want any others */
 	if (machine__uses_kcore(machine))
 		return 0;
 	machine__mmap_name(machine, kmmap_prefix, sizeof(kmmap_prefix));
 	if (machine__is_host(machine))
 		kernel_type = DSO_TYPE_KERNEL;
 	else
 		kernel_type = DSO_TYPE_GUEST_KERNEL;
 	is_kernel_mmap = memcmp(event->mmap.filename,
 				kmmap_prefix,
 				strlen(kmmap_prefix) - 1) == 0;
 	if (event->mmap.filename[0] == '/' ||
 	    (!is_kernel_mmap && event->mmap.filename[0] == '[')) {
 		char short_module_name[1024];
 		char *name, *dot;
 		if (event->mmap.filename[0] == '/') {
 			name = strrchr(event->mmap.filename, '/');
 			if (name == NULL)
 				goto out_problem;
 			++name; /* skip / */
 			dot = strrchr(name, '.');
 			if (dot == NULL)
 				goto out_problem;
 			/* On some system, modules are compressed like .ko.gz */
 			if (is_supported_compression(dot + 1))
 				dot -= 3;
 			if (!is_kmodule_extension(dot + 1))
 				goto out_problem;
 			snprintf(short_module_name, sizeof(short_module_name),
 					"[%.*s]", (int)(dot - name), name);
 			strxfrchar(short_module_name, '-', '_');
 		} else
 			strcpy(short_module_name, event->mmap.filename);
 		map = machine__new_module(machine, event->mmap.start,
 					  event->mmap.filename);
 		if (map == NULL)
 			goto out_problem;
 		name = strdup(short_module_name);
 		if (name == NULL)
 			goto out_problem;
 		dso__set_short_name(map->dso, name, true);
 		map->end = map->start + event->mmap.len;
 	} else if (is_kernel_mmap) {
 		const char *symbol_name = (event->mmap.filename +
 				strlen(kmmap_prefix));
 		/*
 		 * Should be there already, from the build-id table in
 		 * the header.
 		 */
 		struct dso *kernel = NULL;
 		struct dso *dso;
 		list_for_each_entry(dso, &machine->kernel_dsos.head, node) {
 			if (is_kernel_module(dso->long_name, NULL))
 				continue;
 			kernel = dso;
 			break;
 		}
 		if (kernel == NULL)
 			kernel = __dsos__findnew(&machine->kernel_dsos,
 						 kmmap_prefix);
 		if (kernel == NULL)
 			goto out_problem;
 		kernel->kernel = kernel_type;
 		if (__machine__create_kernel_maps(machine, kernel) < 0)
 			goto out_problem;
 		if (strstr(kernel->long_name, "vmlinux"))
 			dso__set_short_name(kernel, "[kernel.vmlinux]", false);
 		machine__set_kernel_mmap_len(machine, event);
 		/*
 		 * Avoid using a zero address (kptr_restrict) for the ref reloc
 		 * symbol. Effectively having zero here means that at record
 		 * time /proc/sys/kernel/kptr_restrict was non zero.
 		 */
 		if (event->mmap.pgoff != 0) {
 			maps__set_kallsyms_ref_reloc_sym(machine->vmlinux_maps,
 							 symbol_name,
 							 event->mmap.pgoff);
 		}
 		if (machine__is_default_guest(machine)) {
 			/*
 			 * preload dso of guest kernel and modules
 			 */
 			dso__load(kernel, machine->vmlinux_maps[MAP__FUNCTION],
 				  NULL);
 		}
 	}
 	return 0;
 out_problem:
 	return -1;
 }
 int machine__process_mmap2_event(struct machine *machine,
 				 union perf_event *event,
 				 struct perf_sample *sample __maybe_unused)
 {
 	u8 cpumode = event->header.misc & PERF_RECORD_MISC_CPUMODE_MASK;
 	struct thread *thread;
 	struct map *map;
 	enum map_type type;
 	int ret = 0;
 	if (dump_trace)
 		perf_event__fprintf_mmap2(event, stdout);
 	if (cpumode == PERF_RECORD_MISC_GUEST_KERNEL ||
 	    cpumode == PERF_RECORD_MISC_KERNEL) {
 		ret = machine__process_kernel_mmap_event(machine, event);
 		if (ret < 0)
 			goto out_problem;
 		return 0;
 	}
 	thread = machine__findnew_thread(machine, event->mmap2.pid,
 					event->mmap2.tid);
 	if (thread == NULL)
 		goto out_problem;
 	if (event->header.misc & PERF_RECORD_MISC_MMAP_DATA)
 		type = MAP__VARIABLE;
 	else
 		type = MAP__FUNCTION;
 	map = map__new(machine, event->mmap2.start,
 			event->mmap2.len, event->mmap2.pgoff,
 			event->mmap2.pid, event->mmap2.maj,
 			event->mmap2.min, event->mmap2.ino,
 			event->mmap2.ino_generation,
 			event->mmap2.prot,
 			event->mmap2.flags,
 			event->mmap2.filename, type, thread);
 	if (map == NULL)
 		goto out_problem;
 	thread__insert_map(thread, map);
 	return 0;
 out_problem:
 	dump_printf("problem processing PERF_RECORD_MMAP2, skipping event.\n");
 	return 0;
 }
 int machine__process_mmap_event(struct machine *machine, union perf_event *event,
 				struct perf_sample *sample __maybe_unused)
 {
 	u8 cpumode = event->header.misc & PERF_RECORD_MISC_CPUMODE_MASK;
 	struct thread *thread;
 	struct map *map;
 	enum map_type type;
 	int ret = 0;
 	if (dump_trace)
 		perf_event__fprintf_mmap(event, stdout);
 	if (cpumode == PERF_RECORD_MISC_GUEST_KERNEL ||
 	    cpumode == PERF_RECORD_MISC_KERNEL) {
 		ret = machine__process_kernel_mmap_event(machine, event);
 		if (ret < 0)
 			goto out_problem;
 		return 0;
 	}
 	thread = machine__findnew_thread(machine, event->mmap.pid,
 					 event->mmap.tid);
 	if (thread == NULL)
 		goto out_problem;
 	if (event->header.misc & PERF_RECORD_MISC_MMAP_DATA)
 		type = MAP__VARIABLE;
 	else
 		type = MAP__FUNCTION;
 	map = map__new(machine, event->mmap.start,
 			event->mmap.len, event->mmap.pgoff,
 			event->mmap.pid, 0, 0, 0, 0, 0, 0,
 			event->mmap.filename,
 			type, thread);
 	if (map == NULL)
 		goto out_problem;
 	thread__insert_map(thread, map);
 	return 0;
 out_problem:
 	dump_printf("problem processing PERF_RECORD_MMAP, skipping event.\n");
 	return 0;
 }
 static void machine__remove_thread(struct machine *machine, struct thread *th)
 {
 	machine->last_match = NULL;
 	rb_erase(&th->rb_node, &machine->threads);
 	/*
 	 * We may have references to this thread, for instance in some hist_entry
 	 * instances, so just move them to a separate list.
 	 */
 	list_add_tail(&th->node, &machine->dead_threads);
 }
 int machine__process_fork_event(struct machine *machine, union perf_event *event,
 				struct perf_sample *sample)
 {
 	struct thread *thread = machine__find_thread(machine,
 						     event->fork.pid,
 						     event->fork.tid);
 	struct thread *parent = machine__findnew_thread(machine,
 							event->fork.ppid,
 							event->fork.ptid);
 	/* if a thread currently exists for the thread id remove it */
 	if (thread != NULL)
 		machine__remove_thread(machine, thread);
 	thread = machine__findnew_thread(machine, event->fork.pid,
 					 event->fork.tid);
 	if (dump_trace)
 		perf_event__fprintf_task(event, stdout);
 	if (thread == NULL || parent == NULL ||
 	    thread__fork(thread, parent, sample->time) < 0) {
 		dump_printf("problem processing PERF_RECORD_FORK, skipping event.\n");
 		return -1;
 	}
 	return 0;
 }
 int machine__process_exit_event(struct machine *machine, union perf_event *event,
 				struct perf_sample *sample __maybe_unused)
 {
 	struct thread *thread = machine__find_thread(machine,
 						     event->fork.pid,
 						     event->fork.tid);
 	if (dump_trace)
 		perf_event__fprintf_task(event, stdout);
 	if (thread != NULL)
 		thread__exited(thread);
 	return 0;
 }
 int machine__process_event(struct machine *machine, union perf_event *event,
 			   struct perf_sample *sample)
 {
 	int ret;
 	switch (event->header.type) {
 	case PERF_RECORD_COMM:
 		ret = machine__process_comm_event(machine, event, sample); break;
 	case PERF_RECORD_MMAP:
 		ret = machine__process_mmap_event(machine, event, sample); break;
 	case PERF_RECORD_MMAP2:
 		ret = machine__process_mmap2_event(machine, event, sample); break;
 	case PERF_RECORD_FORK:
 		ret = machine__process_fork_event(machine, event, sample); break;
 	case PERF_RECORD_EXIT:
 		ret = machine__process_exit_event(machine, event, sample); break;
 	case PERF_RECORD_LOST:
 		ret = machine__process_lost_event(machine, event, sample); break;
 	default:
 		ret = -1;
 		break;
 	}
 	return ret;
 }
 static bool symbol__match_regex(struct symbol *sym, regex_t *regex)
 {
 	if (sym->name && !regexec(regex, sym->name, 0, NULL, 0))
 		return 1;
 	return 0;
 }
 static void ip__resolve_ams(struct thread *thread,
 			    struct addr_map_symbol *ams,
 			    u64 ip)
 {
 	struct addr_location al;
 	memset(&al, 0, sizeof(al));
 	/*
 	 * We cannot use the header.misc hint to determine whether a
 	 * branch stack address is user, kernel, guest, hypervisor.
 	 * Branches may straddle the kernel/user/hypervisor boundaries.
 	 * Thus, we have to try consecutively until we find a match
 	 * or else, the symbol is unknown
 	 */
 	thread__find_cpumode_addr_location(thread, MAP__FUNCTION, ip, &al);
 	ams->addr = ip;
 	ams->al_addr = al.addr;
 	ams->sym = al.sym;
 	ams->map = al.map;
 }
 static void ip__resolve_data(struct thread *thread,
 			     u8 m, struct addr_map_symbol *ams, u64 addr)
 {
 	struct addr_location al;
 	memset(&al, 0, sizeof(al));
 	thread__find_addr_location(thread, m, MAP__VARIABLE, addr, &al);
 	if (al.map == NULL) {
 		/*
 		 * some shared data regions have execute bit set which puts
 		 * their mapping in the MAP__FUNCTION type array.
 		 * Check there as a fallback option before dropping the sample.
 		 */
 		thread__find_addr_location(thread, m, MAP__FUNCTION, addr, &al);
 	}
 	ams->addr = addr;
 	ams->al_addr = al.addr;
 	ams->sym = al.sym;
 	ams->map = al.map;
 }
 struct mem_info *sample__resolve_mem(struct perf_sample *sample,
 				     struct addr_location *al)
 {
 	struct mem_info *mi = zalloc(sizeof(*mi));
 	if (!mi)
 		return NULL;
 	ip__resolve_ams(al->thread, &mi->iaddr, sample->ip);
 	ip__resolve_data(al->thread, al->cpumode, &mi->daddr, sample->addr);
 	mi->data_src.val = sample->data_src;
 	return mi;
 }
 static int add_callchain_ip(struct thread *thread,
 			    struct symbol **parent,
 			    struct addr_location *root_al,
 			    bool branch_history,
 			    u64 ip)
 {
 	struct addr_location al;
 	al.filtered = 0;
 	al.sym = NULL;
 	if (branch_history)
 		thread__find_cpumode_addr_location(thread, MAP__FUNCTION,
 						   ip, &al);
 	else {
 		u8 cpumode = PERF_RECORD_MISC_USER;
 		if (ip >= PERF_CONTEXT_MAX) {
 			switch (ip) {
 			case PERF_CONTEXT_HV:
 				cpumode = PERF_RECORD_MISC_HYPERVISOR;
 				break;
 			case PERF_CONTEXT_KERNEL:
 				cpumode = PERF_RECORD_MISC_KERNEL;
 				break;
 			case PERF_CONTEXT_USER:
 				cpumode = PERF_RECORD_MISC_USER;
 				break;
 			default:
 				pr_debug("invalid callchain context: "
 					 "%"PRId64"\n", (s64) ip);
 				/*
 				 * It seems the callchain is corrupted.
 				 * Discard all.
 				 */
 				callchain_cursor_reset(&callchain_cursor);
 				return 1;
 			}
 			return 0;
 		}
 		thread__find_addr_location(thread, cpumode, MAP__FUNCTION,
 				   ip, &al);
 	}
 	if (al.sym != NULL) {
 		if (sort__has_parent && !*parent &&
 		    symbol__match_regex(al.sym, &parent_regex))
 			*parent = al.sym;
 		else if (have_ignore_callees && root_al &&
 		  symbol__match_regex(al.sym, &ignore_callees_regex)) {
 			/* Treat this symbol as the root,
 			   forgetting its callees. */
 			*root_al = al;
 			callchain_cursor_reset(&callchain_cursor);
 		}
 	}
 	return callchain_cursor_append(&callchain_cursor, al.addr, al.map, al.sym);
 }
 struct branch_info *sample__resolve_bstack(struct perf_sample *sample,
 					   struct addr_location *al)
 {
 	unsigned int i;
 	const struct branch_stack *bs = sample->branch_stack;
 	struct branch_info *bi = calloc(bs->nr, sizeof(struct branch_info));
 	if (!bi)
 		return NULL;
 	for (i = 0; i < bs->nr; i++) {
 		ip__resolve_ams(al->thread, &bi[i].to, bs->entries[i].to);
 		ip__resolve_ams(al->thread, &bi[i].from, bs->entries[i].from);
 		bi[i].flags = bs->entries[i].flags;
 	}
 	return bi;
 }
 #define CHASHSZ 127
 #define CHASHBITS 7
 #define NO_ENTRY 0xff
 #define PERF_MAX_BRANCH_DEPTH 127
 /* Remove loops. */
 static int remove_loops(struct branch_entry *l, int nr)
 {
 	int i, j, off;
 	unsigned char chash[CHASHSZ];
 	memset(chash, NO_ENTRY, sizeof(chash));
 	BUG_ON(PERF_MAX_BRANCH_DEPTH > 255);
 	for (i = 0; i < nr; i++) {
 		int h = hash_64(l[i].from, CHASHBITS) % CHASHSZ;
 		/* no collision handling for now */
 		if (chash[h] == NO_ENTRY) {
 			chash[h] = i;
 		} else if (l[chash[h]].from == l[i].from) {
 			bool is_loop = true;
 			/* check if it is a real loop */
 			off = 0;
 			for (j = chash[h]; j < i && i + off < nr; j++, off++)
 				if (l[j].from != l[i + off].from) {
 					is_loop = false;
 					break;
 				}
 			if (is_loop) {
 				memmove(l + i, l + i + off,
 					(nr - (i + off)) * sizeof(*l));
 				nr -= off;
 			}
 		}
 	}
 	return nr;
 }
 static int thread__resolve_callchain_sample(struct thread *thread,
 					     struct ip_callchain *chain,
 					     struct branch_stack *branch,
 					     struct symbol **parent,
 					     struct addr_location *root_al,
 					     int max_stack)
 {
 	int chain_nr = min(max_stack, (int)chain->nr);
 	int i, j, err;
 	int skip_idx = -1;
 	int first_call = 0;
 	/*
 	 * Based on DWARF debug information, some architectures skip
 	 * a callchain entry saved by the kernel.
 	 */
 	if (chain->nr < PERF_MAX_STACK_DEPTH)
 		skip_idx = arch_skip_callchain_idx(thread, chain);
 	callchain_cursor_reset(&callchain_cursor);
 	/*
 	 * Add branches to call stack for easier browsing. This gives
 	 * more context for a sample than just the callers.
 	 *
 	 * This uses individual histograms of paths compared to the
 	 * aggregated histograms the normal LBR mode uses.
 	 *
 	 * Limitations for now:
 	 * - No extra filters
 	 * - No annotations (should annotate somehow)
 	 */
 	if (branch && callchain_param.branch_callstack) {
 		int nr = min(max_stack, (int)branch->nr);
 		struct branch_entry be[nr];
 		if (branch->nr > PERF_MAX_BRANCH_DEPTH) {
 			pr_warning("corrupted branch chain. skipping...\n");
 			goto check_calls;
 		}
 		for (i = 0; i < nr; i++) {
 			if (callchain_param.order == ORDER_CALLEE) {
 				be[i] = branch->entries[i];
 				/*
 				 * Check for overlap into the callchain.
 				 * The return address is one off compared to
 				 * the branch entry. To adjust for this
 				 * assume the calling instruction is not longer
 				 * than 8 bytes.
 				 */
 				if (i == skip_idx ||
 				    chain->ips[first_call] >= PERF_CONTEXT_MAX)
 					first_call++;
 				else if (be[i].from < chain->ips[first_call] &&
 				    be[i].from >= chain->ips[first_call] - 8)
 					first_call++;
 			} else
 				be[i] = branch->entries[branch->nr - i - 1];
 		}
 		nr = remove_loops(be, nr);
 		for (i = 0; i < nr; i++) {
 			err = add_callchain_ip(thread, parent, root_al,
 					       true, be[i].to);
 			if (!err)
 				err = add_callchain_ip(thread, parent, root_al,
 						       true, be[i].from);
 			if (err == -EINVAL)
 				break;
 			if (err)
 				return err;
 		}
 		chain_nr -= nr;
 	}
 check_calls:
 	if (chain->nr > PERF_MAX_STACK_DEPTH) {
 		pr_warning("corrupted callchain. skipping...\n");
 		return 0;
 	}
 	for (i = first_call; i < chain_nr; i++) {
 		u64 ip;
 		if (callchain_param.order == ORDER_CALLEE)
 			j = i;
 		else
 			j = chain->nr - i - 1;
 #ifdef HAVE_SKIP_CALLCHAIN_IDX
 		if (j == skip_idx)
 			continue;
 #endif
 		ip = chain->ips[j];
 		err = add_callchain_ip(thread, parent, root_al, false, ip);
 		if (err)
 			return (err < 0) ? err : 0;
 	}
 	return 0;
 }
 static int unwind_entry(struct unwind_entry *entry, void *arg)
 {
 	struct callchain_cursor *cursor = arg;
 	return callchain_cursor_append(cursor, entry->ip,
 				       entry->map, entry->sym);
 }
 int thread__resolve_callchain(struct thread *thread,
 			      struct perf_evsel *evsel,
 			      struct perf_sample *sample,
 			      struct symbol **parent,
 			      struct addr_location *root_al,
 			      int max_stack)
 {
 	int ret = thread__resolve_callchain_sample(thread, sample->callchain,
 						   sample->branch_stack,
 						   parent, root_al, max_stack);
 	if (ret)
 		return ret;
 	/* Can we do dwarf post unwind? */
 	if (!((evsel->attr.sample_type & PERF_SAMPLE_REGS_USER) &&
 	      (evsel->attr.sample_type & PERF_SAMPLE_STACK_USER)))
 		return 0;
 	/* Bail out if nothing was captured. */
 	if ((!sample->user_regs.regs) ||
 	    (!sample->user_stack.size))
 		return 0;
 	return unwind__get_entries(unwind_entry, &callchain_cursor,
 				   thread, sample, max_stack);
 }
 int machine__for_each_thread(struct machine *machine,
 			     int (*fn)(struct thread *thread, void *p),
 			     void *priv)
 {
 	struct rb_node *nd;
 	struct thread *thread;
 	int rc = 0;
 	for (nd = rb_first(&machine->threads); nd; nd = rb_next(nd)) {
 		thread = rb_entry(nd, struct thread, rb_node);
 		rc = fn(thread, priv);
 		if (rc != 0)
 			return rc;
 	}
 	list_for_each_entry(thread, &machine->dead_threads, node) {
 		rc = fn(thread, priv);
 		if (rc != 0)
 			return rc;
 	}
 	return rc;
 }
 int __machine__synthesize_threads(struct machine *machine, struct perf_tool *tool,
 				  struct target *target, struct thread_map *threads,
 				  perf_event__handler_t process, bool data_mmap)
 {
 	if (target__has_task(target))
 		return perf_event__synthesize_thread_map(tool, threads, process, machine, data_mmap);
 	else if (target__has_cpu(target))
 		return perf_event__synthesize_threads(tool, process, machine, data_mmap);
 	/* command specified */
 	return 0;
 }
 pid_t machine__get_current_tid(struct machine *machine, int cpu)
 {
 	if (cpu < 0 || cpu >= MAX_NR_CPUS || !machine->current_tid)
 		return -1;
 	return machine->current_tid[cpu];
 }
 int machine__set_current_tid(struct machine *machine, int cpu, pid_t pid,
 			     pid_t tid)
 {
 	struct thread *thread;
 	if (cpu < 0)
 		return -EINVAL;
 	if (!machine->current_tid) {
 		int i;
 		machine->current_tid = calloc(MAX_NR_CPUS, sizeof(pid_t));
 		if (!machine->current_tid)
 			return -ENOMEM;
 		for (i = 0; i < MAX_NR_CPUS; i++)
 			machine->current_tid[i] = -1;
 	}
 	if (cpu >= MAX_NR_CPUS) {
 		pr_err("Requested CPU %d too large. ", cpu);
 		pr_err("Consider raising MAX_NR_CPUS\n");
 		return -EINVAL;
 	}
 	machine->current_tid[cpu] = tid;
 	thread = machine__findnew_thread(machine, pid, tid);
 	if (!thread)
 		return -ENOMEM;
 	thread->cpu = cpu;
 	return 0;
 }
 int machine__get_kernel_start(struct machine *machine)
 {
 	struct map *map = machine__kernel_map(machine, MAP__FUNCTION);
 	int err = 0;
 	/*
 	 * The only addresses above 2^63 are kernel addresses of a 64-bit
 	 * kernel.  Note that addresses are unsigned so that on a 32-bit system
 	 * all addresses including kernel addresses are less than 2^32.  In
 	 * that case (32-bit system), if the kernel mapping is unknown, all
 	 * addresses will be assumed to be in user space - see
 	 * machine__kernel_ip().
 	 */
 	machine->kernel_start = 1ULL << 63;
 	if (map) {
 		err = map__load(map, machine->symbol_filter);
 		if (map->start)
 			machine->kernel_start = map->start;
 	}
 	return err;
 }

tools/perf/util/probe-event.c

Diff comments View file @ 59b2858

 /*
  * probe-event.c : perf-probe definition to probe_events format converter
  *
  * Written by Masami Hiramatsu <mhiramat@redhat.com>
  *
  * This program is free software; you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
  * the Free Software Foundation; either version 2 of the License, or
  * (at your option) any later version.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
  *
  * You should have received a copy of the GNU General Public License
  * along with this program; if not, write to the Free Software
  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
  *
  */
 #include <sys/utsname.h>
 #include <sys/types.h>
 #include <sys/stat.h>
 #include <fcntl.h>
 #include <errno.h>
 #include <stdio.h>
 #include <unistd.h>
 #include <stdlib.h>
 #include <string.h>
 #include <stdarg.h>
 #include <limits.h>
 #include <elf.h>
 #include "util.h"
 #include "event.h"
 #include "strlist.h"
 #include "debug.h"
 #include "cache.h"
 #include "color.h"
 #include "symbol.h"
 #include "thread.h"
 #include <api/fs/debugfs.h>
 #include "trace-event.h"	/* For __maybe_unused */
 #include "probe-event.h"
 #include "probe-finder.h"
 #include "session.h"
 #define MAX_CMDLEN 256
 #define PERFPROBE_GROUP "probe"
 bool probe_event_dry_run;	/* Dry run flag */
 #define semantic_error(msg ...) pr_err("Semantic error :" msg)
 /* If there is no space to write, returns -E2BIG. */
 static int e_snprintf(char *str, size_t size, const char *format, ...)
 	__attribute__((format(printf, 3, 4)));
 static int e_snprintf(char *str, size_t size, const char *format, ...)
 {
 	int ret;
 	va_list ap;
 	va_start(ap, format);
 	ret = vsnprintf(str, size, format, ap);
 	va_end(ap);
 	if (ret >= (int)size)
 		ret = -E2BIG;
 	return ret;
 }
 static char *synthesize_perf_probe_point(struct perf_probe_point *pp);
 static void clear_probe_trace_event(struct probe_trace_event *tev);
 static struct machine *host_machine;
 /* Initialize symbol maps and path of vmlinux/modules */
 static int init_symbol_maps(bool user_only)
 {
 	int ret;
 	symbol_conf.sort_by_name = true;
 	ret = symbol__init(NULL);
 	if (ret < 0) {
 		pr_debug("Failed to init symbol map.\n");
 		goto out;
 	}
 	if (host_machine || user_only)	/* already initialized */
 		return 0;
 	if (symbol_conf.vmlinux_name)
 		pr_debug("Use vmlinux: %s\n", symbol_conf.vmlinux_name);
 	host_machine = machine__new_host();
 	if (!host_machine) {
 		pr_debug("machine__new_host() failed.\n");
 		symbol__exit();
 		ret = -1;
 	}
 out:
 	if (ret < 0)
 		pr_warning("Failed to init vmlinux path.\n");
 	return ret;
 }
 static void exit_symbol_maps(void)
 {
 	if (host_machine) {
 		machine__delete(host_machine);
 		host_machine = NULL;
 	}
 	symbol__exit();
 }
 static struct symbol *__find_kernel_function_by_name(const char *name,
 						     struct map **mapp)
 {
 	return machine__find_kernel_function_by_name(host_machine, name, mapp,
 						     NULL);
 }
 static struct symbol *__find_kernel_function(u64 addr, struct map **mapp)
 {
 	return machine__find_kernel_function(host_machine, addr, mapp, NULL);
 }
 static struct ref_reloc_sym *kernel_get_ref_reloc_sym(void)
 {
 	/* kmap->ref_reloc_sym should be set if host_machine is initialized */
 	struct kmap *kmap;
 	if (map__load(host_machine->vmlinux_maps[MAP__FUNCTION], NULL) < 0)
 		return NULL;
 	kmap = map__kmap(host_machine->vmlinux_maps[MAP__FUNCTION]);
 	return kmap->ref_reloc_sym;
 }
 static u64 kernel_get_symbol_address_by_name(const char *name, bool reloc)
 {
 	struct ref_reloc_sym *reloc_sym;
 	struct symbol *sym;
 	struct map *map;
 	/* ref_reloc_sym is just a label. Need a special fix*/
 	reloc_sym = kernel_get_ref_reloc_sym();
 	if (reloc_sym && strcmp(name, reloc_sym->name) == 0)
 		return (reloc) ? reloc_sym->addr : reloc_sym->unrelocated_addr;
 	else {
 		sym = __find_kernel_function_by_name(name, &map);
 		if (sym)
 			return map->unmap_ip(map, sym->start) -
 				(reloc) ? 0 : map->reloc;
 	}
 	return 0;
 }
 static struct map *kernel_get_module_map(const char *module)
 {
 	struct rb_node *nd;
 	struct map_groups *grp = &host_machine->kmaps;
 	/* A file path -- this is an offline module */
 	if (module && strchr(module, '/'))
 		return machine__new_module(host_machine, 0, module);
 	if (!module)
 		module = "kernel";
 	for (nd = rb_first(&grp->maps[MAP__FUNCTION]); nd; nd = rb_next(nd)) {
 		struct map *pos = rb_entry(nd, struct map, rb_node);
 		if (strncmp(pos->dso->short_name + 1, module,
 			    pos->dso->short_name_len - 2) == 0) {
 			return pos;
 		}
 	}
 	return NULL;
 }
 static struct dso *kernel_get_module_dso(const char *module)
 {
 	struct dso *dso;
 	struct map *map;
 	const char *vmlinux_name;
 	if (module) {
 		list_for_each_entry(dso, &host_machine->kernel_dsos.head,
 				    node) {
 			if (strncmp(dso->short_name + 1, module,
 				    dso->short_name_len - 2) == 0)
 				goto found;
 		}
 		pr_debug("Failed to find module %s.\n", module);
 		return NULL;
 	}
 	map = host_machine->vmlinux_maps[MAP__FUNCTION];
 	dso = map->dso;
 	vmlinux_name = symbol_conf.vmlinux_name;
 	if (vmlinux_name) {
 		if (dso__load_vmlinux(dso, map, vmlinux_name, false, NULL) <= 0)
 			return NULL;
 	} else {
 		if (dso__load_vmlinux_path(dso, map, NULL) <= 0) {
 			pr_debug("Failed to load kernel map.\n");
 			return NULL;
 		}
 	}
 found:
 	return dso;
 }
 const char *kernel_get_module_path(const char *module)
 {
 	struct dso *dso = kernel_get_module_dso(module);
 	return (dso) ? dso->long_name : NULL;
 }
 static int convert_exec_to_group(const char *exec, char **result)
 {
 	char *ptr1, *ptr2, *exec_copy;
 	char buf[64];
 	int ret;
 	exec_copy = strdup(exec);
 	if (!exec_copy)
 		return -ENOMEM;
 	ptr1 = basename(exec_copy);
 	if (!ptr1) {
 		ret = -EINVAL;
 		goto out;
 	}
 	ptr2 = strpbrk(ptr1, "-._");
 	if (ptr2)
 		*ptr2 = '\0';
 	ret = e_snprintf(buf, 64, "%s_%s", PERFPROBE_GROUP, ptr1);
 	if (ret < 0)
 		goto out;
 	*result = strdup(buf);
 	ret = *result ? 0 : -ENOMEM;
 out:
 	free(exec_copy);
 	return ret;
 }
 static void clear_probe_trace_events(struct probe_trace_event *tevs, int ntevs)
 {
 	int i;
 	for (i = 0; i < ntevs; i++)
 		clear_probe_trace_event(tevs + i);
 }
 #ifdef HAVE_DWARF_SUPPORT
 /* Open new debuginfo of given module */
 static struct debuginfo *open_debuginfo(const char *module, bool silent)
 {
 	const char *path = module;
 	struct debuginfo *ret;
 	if (!module || !strchr(module, '/')) {
 		path = kernel_get_module_path(module);
 		if (!path) {
 			if (!silent)
 				pr_err("Failed to find path of %s module.\n",
 				       module ?: "kernel");
 			return NULL;
 		}
 	}
 	ret = debuginfo__new(path);
 	if (!ret && !silent) {
 		pr_warning("The %s file has no debug information.\n", path);
 		if (!module || !strtailcmp(path, ".ko"))
 			pr_warning("Rebuild with CONFIG_DEBUG_INFO=y, ");
 		else
 			pr_warning("Rebuild with -g, ");
 		pr_warning("or install an appropriate debuginfo package.\n");
 	}
 	return ret;
 }
 static int get_text_start_address(const char *exec, unsigned long *address)
 {
 	Elf *elf;
 	GElf_Ehdr ehdr;
 	GElf_Shdr shdr;
 	int fd, ret = -ENOENT;
 	fd = open(exec, O_RDONLY);
 	if (fd < 0)
 		return -errno;
 	elf = elf_begin(fd, PERF_ELF_C_READ_MMAP, NULL);
 	if (elf == NULL)
 		return -EINVAL;
 	if (gelf_getehdr(elf, &ehdr) == NULL)
 		goto out;
 	if (!elf_section_by_name(elf, &ehdr, &shdr, ".text", NULL))
 		goto out;
 	*address = shdr.sh_addr - shdr.sh_offset;
 	ret = 0;
 out:
 	elf_end(elf);
 	return ret;
 }
 /*
  * Convert trace point to probe point with debuginfo
  */
 static int find_perf_probe_point_from_dwarf(struct probe_trace_point *tp,
 					    struct perf_probe_point *pp,
 					    bool is_kprobe)
 {
 	struct debuginfo *dinfo = NULL;
 	unsigned long stext = 0;
 	u64 addr = tp->address;
 	int ret = -ENOENT;
 	/* convert the address to dwarf address */
 	if (!is_kprobe) {
 		if (!addr) {
 			ret = -EINVAL;
 			goto error;
 		}
 		ret = get_text_start_address(tp->module, &stext);
 		if (ret < 0)
 			goto error;
 		addr += stext;
 	} else {
 		addr = kernel_get_symbol_address_by_name(tp->symbol, false);
 		if (addr == 0)
 			goto error;
 		addr += tp->offset;
 	}
 	pr_debug("try to find information at %" PRIx64 " in %s\n", addr,
 		 tp->module ? : "kernel");
 	dinfo = open_debuginfo(tp->module, verbose == 0);
 	if (dinfo) {
 		ret = debuginfo__find_probe_point(dinfo,
 						 (unsigned long)addr, pp);
 		debuginfo__delete(dinfo);
 	} else
 		ret = -ENOENT;
 	if (ret > 0) {
 		pp->retprobe = tp->retprobe;
 		return 0;
 	}
 error:
 	pr_debug("Failed to find corresponding probes from debuginfo.\n");
 	return ret ? : -ENOENT;
 }
 static int add_exec_to_probe_trace_events(struct probe_trace_event *tevs,
 					  int ntevs, const char *exec)
 {
 	int i, ret = 0;
 	unsigned long stext = 0;
 	if (!exec)
 		return 0;
 	ret = get_text_start_address(exec, &stext);
 	if (ret < 0)
 		return ret;
 	for (i = 0; i < ntevs && ret >= 0; i++) {
 		/* point.address is the addres of point.symbol + point.offset */
 		tevs[i].point.address -= stext;
 		tevs[i].point.module = strdup(exec);
 		if (!tevs[i].point.module) {
 			ret = -ENOMEM;
 			break;
 		}
 		tevs[i].uprobes = true;
 	}
 	return ret;
 }
 static int add_module_to_probe_trace_events(struct probe_trace_event *tevs,
 					    int ntevs, const char *module)
 {
 	int i, ret = 0;
 	char *tmp;
 	if (!module)
 		return 0;
 	tmp = strrchr(module, '/');
 	if (tmp) {
 		/* This is a module path -- get the module name */
 		module = strdup(tmp + 1);
 		if (!module)
 			return -ENOMEM;
 		tmp = strchr(module, '.');
 		if (tmp)
 			*tmp = '\0';
 		tmp = (char *)module;	/* For free() */
 	}
 	for (i = 0; i < ntevs; i++) {
 		tevs[i].point.module = strdup(module);
 		if (!tevs[i].point.module) {
 			ret = -ENOMEM;
 			break;
 		}
 	}
 	free(tmp);
 	return ret;
 }
 /* Post processing the probe events */
 static int post_process_probe_trace_events(struct probe_trace_event *tevs,
 					   int ntevs, const char *module,
 					   bool uprobe)
 {
 	struct ref_reloc_sym *reloc_sym;
 	char *tmp;
 	int i;
 	if (uprobe)
 		return add_exec_to_probe_trace_events(tevs, ntevs, module);
 	/* Note that currently ref_reloc_sym based probe is not for drivers */
 	if (module)
 		return add_module_to_probe_trace_events(tevs, ntevs, module);
 	reloc_sym = kernel_get_ref_reloc_sym();
 	if (!reloc_sym) {
 		pr_warning("Relocated base symbol is not found!\n");
 		return -EINVAL;
 	}
 	for (i = 0; i < ntevs; i++) {
 		if (tevs[i].point.address) {
 			tmp = strdup(reloc_sym->name);
 			if (!tmp)
 				return -ENOMEM;
 			free(tevs[i].point.symbol);
 			tevs[i].point.symbol = tmp;
 			tevs[i].point.offset = tevs[i].point.address -
 					       reloc_sym->unrelocated_addr;
 		}
 	}
 	return 0;
 }
 /* Try to find perf_probe_event with debuginfo */
 static int try_to_find_probe_trace_events(struct perf_probe_event *pev,
 					  struct probe_trace_event **tevs,
 					  int max_tevs, const char *target)
 {
 	bool need_dwarf = perf_probe_event_need_dwarf(pev);
 	struct debuginfo *dinfo;
 	int ntevs, ret = 0;
 	dinfo = open_debuginfo(target, !need_dwarf);
 	if (!dinfo) {
 		if (need_dwarf)
 			return -ENOENT;
 		pr_debug("Could not open debuginfo. Try to use symbols.\n");
 		return 0;
 	}
 	pr_debug("Try to find probe point from debuginfo.\n");
 	/* Searching trace events corresponding to a probe event */
 	ntevs = debuginfo__find_trace_events(dinfo, pev, tevs, max_tevs);
 	debuginfo__delete(dinfo);
 	if (ntevs > 0) {	/* Succeeded to find trace events */
 		pr_debug("Found %d probe_trace_events.\n", ntevs);
 		ret = post_process_probe_trace_events(*tevs, ntevs,
 							target, pev->uprobes);
 		if (ret < 0) {
 			clear_probe_trace_events(*tevs, ntevs);
 			zfree(tevs);
 		}
 		return ret < 0 ? ret : ntevs;
 	}
 	if (ntevs == 0)	{	/* No error but failed to find probe point. */
 		pr_warning("Probe point '%s' not found in debuginfo.\n",
 			   synthesize_perf_probe_point(&pev->point));
 		if (need_dwarf)
 			return -ENOENT;
 		return 0;
 	}
 	/* Error path : ntevs < 0 */
 	pr_debug("An error occurred in debuginfo analysis (%d).\n", ntevs);
 	if (ntevs == -EBADF) {
 		pr_warning("Warning: No dwarf info found in the vmlinux - "
 			"please rebuild kernel with CONFIG_DEBUG_INFO=y.\n");
 		if (!need_dwarf) {
 			pr_debug("Trying to use symbols.\n");
 			return 0;
 		}
 	}
 	return ntevs;
 }
 /*
  * Find a src file from a DWARF tag path. Prepend optional source path prefix
  * and chop off leading directories that do not exist. Result is passed back as
  * a newly allocated path on success.
  * Return 0 if file was found and readable, -errno otherwise.
  */
 static int get_real_path(const char *raw_path, const char *comp_dir,
 			 char **new_path)
 {
 	const char *prefix = symbol_conf.source_prefix;
 	if (!prefix) {
 		if (raw_path[0] != '/' && comp_dir)
 			/* If not an absolute path, try to use comp_dir */
 			prefix = comp_dir;
 		else {
 			if (access(raw_path, R_OK) == 0) {
 				*new_path = strdup(raw_path);
 				return 0;
 			} else
 				return -errno;
 		}
 	}
 	*new_path = malloc((strlen(prefix) + strlen(raw_path) + 2));
 	if (!*new_path)
 		return -ENOMEM;
 	for (;;) {
 		sprintf(*new_path, "%s/%s", prefix, raw_path);
 		if (access(*new_path, R_OK) == 0)
 			return 0;
 		if (!symbol_conf.source_prefix)
 			/* In case of searching comp_dir, don't retry */
 			return -errno;
 		switch (errno) {
 		case ENAMETOOLONG:
 		case ENOENT:
 		case EROFS:
 		case EFAULT:
 			raw_path = strchr(++raw_path, '/');
 			if (!raw_path) {
 				zfree(new_path);
 				return -ENOENT;
 			}
 			continue;
 		default:
 			zfree(new_path);
 			return -errno;
 		}
 	}
 }
 #define LINEBUF_SIZE 256
 #define NR_ADDITIONAL_LINES 2
 static int __show_one_line(FILE *fp, int l, bool skip, bool show_num)
 {
 	char buf[LINEBUF_SIZE], sbuf[STRERR_BUFSIZE];
 	const char *color = show_num ? "" : PERF_COLOR_BLUE;
 	const char *prefix = NULL;
 	do {
 		if (fgets(buf, LINEBUF_SIZE, fp) == NULL)
 			goto error;
 		if (skip)
 			continue;
 		if (!prefix) {
 			prefix = show_num ? "%7d  " : "         ";
 			color_fprintf(stdout, color, prefix, l);
 		}
 		color_fprintf(stdout, color, "%s", buf);
 	} while (strchr(buf, '\n') == NULL);
 	return 1;
 error:
 	if (ferror(fp)) {
 		pr_warning("File read error: %s\n",
 			   strerror_r(errno, sbuf, sizeof(sbuf)));
 		return -1;
 	}
 	return 0;
 }
 static int _show_one_line(FILE *fp, int l, bool skip, bool show_num)
 {
 	int rv = __show_one_line(fp, l, skip, show_num);
 	if (rv == 0) {
 		pr_warning("Source file is shorter than expected.\n");
 		rv = -1;
 	}
 	return rv;
 }
 #define show_one_line_with_num(f,l)	_show_one_line(f,l,false,true)
 #define show_one_line(f,l)		_show_one_line(f,l,false,false)
 #define skip_one_line(f,l)		_show_one_line(f,l,true,false)
 #define show_one_line_or_eof(f,l)	__show_one_line(f,l,false,false)
 /*
  * Show line-range always requires debuginfo to find source file and
  * line number.
  */
 static int __show_line_range(struct line_range *lr, const char *module)
 {
 	int l = 1;
 	struct int_node *ln;
 	struct debuginfo *dinfo;
 	FILE *fp;
 	int ret;
 	char *tmp;
 	char sbuf[STRERR_BUFSIZE];
 	/* Search a line range */
 	dinfo = open_debuginfo(module, false);
 	if (!dinfo)
 		return -ENOENT;
 	ret = debuginfo__find_line_range(dinfo, lr);
 	debuginfo__delete(dinfo);
 	if (ret == 0 || ret == -ENOENT) {
 		pr_warning("Specified source line is not found.\n");
 		return -ENOENT;
 	} else if (ret < 0) {
 		pr_warning("Debuginfo analysis failed.\n");
 		return ret;
 	}
 	/* Convert source file path */
 	tmp = lr->path;
 	ret = get_real_path(tmp, lr->comp_dir, &lr->path);
 	free(tmp);	/* Free old path */
 	if (ret < 0) {
 		pr_warning("Failed to find source file path.\n");
 		return ret;
 	}
 	setup_pager();
 	if (lr->function)
 		fprintf(stdout, "<%s@%s:%d>\n", lr->function, lr->path,
 			lr->start - lr->offset);
 	else
 		fprintf(stdout, "<%s:%d>\n", lr->path, lr->start);
 	fp = fopen(lr->path, "r");
 	if (fp == NULL) {
 		pr_warning("Failed to open %s: %s\n", lr->path,
 			   strerror_r(errno, sbuf, sizeof(sbuf)));
 		return -errno;
 	}
 	/* Skip to starting line number */
 	while (l < lr->start) {
 		ret = skip_one_line(fp, l++);
 		if (ret < 0)
 			goto end;
 	}
 	intlist__for_each(ln, lr->line_list) {
 		for (; ln->i > l; l++) {
 			ret = show_one_line(fp, l - lr->offset);
 			if (ret < 0)
 				goto end;
 		}
 		ret = show_one_line_with_num(fp, l++ - lr->offset);
 		if (ret < 0)
 			goto end;
 	}
 	if (lr->end == INT_MAX)
 		lr->end = l + NR_ADDITIONAL_LINES;
 	while (l <= lr->end) {
 		ret = show_one_line_or_eof(fp, l++ - lr->offset);
 		if (ret <= 0)
 			break;
 	}
 end:
 	fclose(fp);
 	return ret;
 }
 int show_line_range(struct line_range *lr, const char *module, bool user)
 {
 	int ret;
 	ret = init_symbol_maps(user);
 	if (ret < 0)
 		return ret;
 	ret = __show_line_range(lr, module);
 	exit_symbol_maps();
 	return ret;
 }
 static int show_available_vars_at(struct debuginfo *dinfo,
 				  struct perf_probe_event *pev,
 				  int max_vls, struct strfilter *_filter,
 				  bool externs)
 {
 	char *buf;
 	int ret, i, nvars;
 	struct str_node *node;
 	struct variable_list *vls = NULL, *vl;
 	const char *var;
 	buf = synthesize_perf_probe_point(&pev->point);
 	if (!buf)
 		return -EINVAL;
 	pr_debug("Searching variables at %s\n", buf);
 	ret = debuginfo__find_available_vars_at(dinfo, pev, &vls,
 						max_vls, externs);
 	if (ret <= 0) {
 		if (ret == 0 || ret == -ENOENT) {
 			pr_err("Failed to find the address of %s\n", buf);
 			ret = -ENOENT;
 		} else
 			pr_warning("Debuginfo analysis failed.\n");
 		goto end;
 	}
 	/* Some variables are found */
 	fprintf(stdout, "Available variables at %s\n", buf);
 	for (i = 0; i < ret; i++) {
 		vl = &vls[i];
 		/*
 		 * A probe point might be converted to
 		 * several trace points.
 		 */
 		fprintf(stdout, "\t@<%s+%lu>\n", vl->point.symbol,
 			vl->point.offset);
 		zfree(&vl->point.symbol);
 		nvars = 0;
 		if (vl->vars) {
 			strlist__for_each(node, vl->vars) {
 				var = strchr(node->s, '\t') + 1;
 				if (strfilter__compare(_filter, var)) {
 					fprintf(stdout, "\t\t%s\n", node->s);
 					nvars++;
 				}
 			}
 			strlist__delete(vl->vars);
 		}
 		if (nvars == 0)
 			fprintf(stdout, "\t\t(No matched variables)\n");
 	}
 	free(vls);
 end:
 	free(buf);
 	return ret;
 }
 /* Show available variables on given probe point */
 int show_available_vars(struct perf_probe_event *pevs, int npevs,
 			int max_vls, const char *module,
 			struct strfilter *_filter, bool externs)
 {
 	int i, ret = 0;
 	struct debuginfo *dinfo;
 	ret = init_symbol_maps(pevs->uprobes);
 	if (ret < 0)
 		return ret;
 	dinfo = open_debuginfo(module, false);
 	if (!dinfo) {
 		ret = -ENOENT;
 		goto out;
 	}
 	setup_pager();
 	for (i = 0; i < npevs && ret >= 0; i++)
 		ret = show_available_vars_at(dinfo, &pevs[i], max_vls, _filter,
 					     externs);
 	debuginfo__delete(dinfo);
 out:
 	exit_symbol_maps();
 	return ret;
 }
 #else	/* !HAVE_DWARF_SUPPORT */
 static int
 find_perf_probe_point_from_dwarf(struct probe_trace_point *tp __maybe_unused,
 				 struct perf_probe_point *pp __maybe_unused,
 				 bool is_kprobe __maybe_unused)
 {
 	return -ENOSYS;
 }
 static int try_to_find_probe_trace_events(struct perf_probe_event *pev,
 				struct probe_trace_event **tevs __maybe_unused,
 				int max_tevs __maybe_unused,
 				const char *target __maybe_unused)
 {
 	if (perf_probe_event_need_dwarf(pev)) {
 		pr_warning("Debuginfo-analysis is not supported.\n");
 		return -ENOSYS;
 	}
 	return 0;
 }
 int show_line_range(struct line_range *lr __maybe_unused,
 		    const char *module __maybe_unused,
 		    bool user __maybe_unused)
 {
 	pr_warning("Debuginfo-analysis is not supported.\n");
 	return -ENOSYS;
 }
 int show_available_vars(struct perf_probe_event *pevs __maybe_unused,
 			int npevs __maybe_unused, int max_vls __maybe_unused,
 			const char *module __maybe_unused,
 			struct strfilter *filter __maybe_unused,
 			bool externs __maybe_unused)
 {
 	pr_warning("Debuginfo-analysis is not supported.\n");
 	return -ENOSYS;
 }
 #endif
 void line_range__clear(struct line_range *lr)
 {
 	free(lr->function);
 	free(lr->file);
 	free(lr->path);
 	free(lr->comp_dir);
 	intlist__delete(lr->line_list);
 	memset(lr, 0, sizeof(*lr));
 }
 int line_range__init(struct line_range *lr)
 {
 	memset(lr, 0, sizeof(*lr));
 	lr->line_list = intlist__new(NULL);
 	if (!lr->line_list)
 		return -ENOMEM;
 	else
 		return 0;
 }
 static int parse_line_num(char **ptr, int *val, const char *what)
 {
 	const char *start = *ptr;
 	errno = 0;
 	*val = strtol(*ptr, ptr, 0);
 	if (errno || *ptr == start) {
 		semantic_error("'%s' is not a valid number.\n", what);
 		return -EINVAL;
 	}
 	return 0;
 }
 /*
  * Stuff 'lr' according to the line range described by 'arg'.
  * The line range syntax is described by:
  *
  *         SRC[:SLN[+NUM|-ELN]]
  *         FNC[@SRC][:SLN[+NUM|-ELN]]
  */
 int parse_line_range_desc(const char *arg, struct line_range *lr)
 {
 	char *range, *file, *name = strdup(arg);
 	int err;
 	if (!name)
 		return -ENOMEM;
 	lr->start = 0;
 	lr->end = INT_MAX;
 	range = strchr(name, ':');
 	if (range) {
 		*range++ = '\0';
 		err = parse_line_num(&range, &lr->start, "start line");
 		if (err)
 			goto err;
 		if (*range == '+' || *range == '-') {
 			const char c = *range++;
 			err = parse_line_num(&range, &lr->end, "end line");
 			if (err)
 				goto err;
 			if (c == '+') {
 				lr->end += lr->start;
 				/*
 				 * Adjust the number of lines here.
 				 * If the number of lines == 1, the
 				 * the end of line should be equal to
 				 * the start of line.
 				 */
 				lr->end--;
 			}
 		}
 		pr_debug("Line range is %d to %d\n", lr->start, lr->end);
 		err = -EINVAL;
 		if (lr->start > lr->end) {
 			semantic_error("Start line must be smaller"
 				       " than end line.\n");
 			goto err;
 		}
 		if (*range != '\0') {
 			semantic_error("Tailing with invalid str '%s'.\n", range);
 			goto err;
 		}
 	}
 	file = strchr(name, '@');
 	if (file) {
 		*file = '\0';
 		lr->file = strdup(++file);
 		if (lr->file == NULL) {
 			err = -ENOMEM;
 			goto err;
 		}
 		lr->function = name;
 	} else if (strchr(name, '.'))
 		lr->file = name;
 	else
 		lr->function = name;
 	return 0;
 err:
 	free(name);
 	return err;
 }
 /* Check the name is good for event/group */
 static bool check_event_name(const char *name)
 {
 	if (!isalpha(*name) && *name != '_')
 		return false;
 	while (*++name != '\0') {
 		if (!isalpha(*name) && !isdigit(*name) && *name != '_')
 			return false;
 	}
 	return true;
 }
 /* Parse probepoint definition. */
 static int parse_perf_probe_point(char *arg, struct perf_probe_event *pev)
 {
 	struct perf_probe_point *pp = &pev->point;
 	char *ptr, *tmp;
 	char c, nc = 0;
 	/*
 	 * <Syntax>
 	 * perf probe [EVENT=]SRC[:LN|;PTN]
 	 * perf probe [EVENT=]FUNC[@SRC][+OFFS|%return|:LN|;PAT]
 	 *
 	 * TODO:Group name support
 	 */
 	ptr = strpbrk(arg, ";=@+%");
 	if (ptr && *ptr == '=') {	/* Event name */
 		*ptr = '\0';
 		tmp = ptr + 1;
 		if (strchr(arg, ':')) {
 			semantic_error("Group name is not supported yet.\n");
 			return -ENOTSUP;
 		}
 		if (!check_event_name(arg)) {
 			semantic_error("%s is bad for event name -it must "
 				       "follow C symbol-naming rule.\n", arg);
 			return -EINVAL;
 		}
 		pev->event = strdup(arg);
 		if (pev->event == NULL)
 			return -ENOMEM;
 		pev->group = NULL;
 		arg = tmp;
 	}
 	ptr = strpbrk(arg, ";:+@%");
 	if (ptr) {
 		nc = *ptr;
 		*ptr++ = '\0';
 	}
 	tmp = strdup(arg);
 	if (tmp == NULL)
 		return -ENOMEM;
 	/* Check arg is function or file and copy it */
 	if (strchr(tmp, '.'))	/* File */
 		pp->file = tmp;
 	else			/* Function */
 		pp->function = tmp;
 	/* Parse other options */
 	while (ptr) {
 		arg = ptr;
 		c = nc;
 		if (c == ';') {	/* Lazy pattern must be the last part */
 			pp->lazy_line = strdup(arg);
 			if (pp->lazy_line == NULL)
 				return -ENOMEM;
 			break;
 		}
 		ptr = strpbrk(arg, ";:+@%");
 		if (ptr) {
 			nc = *ptr;
 			*ptr++ = '\0';
 		}
 		switch (c) {
 		case ':':	/* Line number */
 			pp->line = strtoul(arg, &tmp, 0);
 			if (*tmp != '\0') {
 				semantic_error("There is non-digit char"
 					       " in line number.\n");
 				return -EINVAL;
 			}
 			break;
 		case '+':	/* Byte offset from a symbol */
 			pp->offset = strtoul(arg, &tmp, 0);
 			if (*tmp != '\0') {
 				semantic_error("There is non-digit character"
 						" in offset.\n");
 				return -EINVAL;
 			}
 			break;
 		case '@':	/* File name */
 			if (pp->file) {
 				semantic_error("SRC@SRC is not allowed.\n");
 				return -EINVAL;
 			}
 			pp->file = strdup(arg);
 			if (pp->file == NULL)
 				return -ENOMEM;
 			break;
 		case '%':	/* Probe places */
 			if (strcmp(arg, "return") == 0) {
 				pp->retprobe = 1;
 			} else {	/* Others not supported yet */
 				semantic_error("%%%s is not supported.\n", arg);
 				return -ENOTSUP;
 			}
 			break;
 		default:	/* Buggy case */
 			pr_err("This program has a bug at %s:%d.\n",
 				__FILE__, __LINE__);
 			return -ENOTSUP;
 			break;
 		}
 	}
 	/* Exclusion check */
 	if (pp->lazy_line && pp->line) {
 		semantic_error("Lazy pattern can't be used with"
 			       " line number.\n");
 		return -EINVAL;
 	}
 	if (pp->lazy_line && pp->offset) {
 		semantic_error("Lazy pattern can't be used with offset.\n");
 		return -EINVAL;
 	}
 	if (pp->line && pp->offset) {
 		semantic_error("Offset can't be used with line number.\n");
 		return -EINVAL;
 	}
 	if (!pp->line && !pp->lazy_line && pp->file && !pp->function) {
 		semantic_error("File always requires line number or "
 			       "lazy pattern.\n");
 		return -EINVAL;
 	}
 	if (pp->offset && !pp->function) {
 		semantic_error("Offset requires an entry function.\n");
 		return -EINVAL;
 	}
 	if (pp->retprobe && !pp->function) {
 		semantic_error("Return probe requires an entry function.\n");
 		return -EINVAL;
 	}
 	if ((pp->offset || pp->line || pp->lazy_line) && pp->retprobe) {
 		semantic_error("Offset/Line/Lazy pattern can't be used with "
 			       "return probe.\n");
 		return -EINVAL;
 	}
 	pr_debug("symbol:%s file:%s line:%d offset:%lu return:%d lazy:%s\n",
 		 pp->function, pp->file, pp->line, pp->offset, pp->retprobe,
 		 pp->lazy_line);
 	return 0;
 }
 /* Parse perf-probe event argument */
 static int parse_perf_probe_arg(char *str, struct perf_probe_arg *arg)
 {
 	char *tmp, *goodname;
 	struct perf_probe_arg_field **fieldp;
 	pr_debug("parsing arg: %s into ", str);
 	tmp = strchr(str, '=');
 	if (tmp) {
 		arg->name = strndup(str, tmp - str);
 		if (arg->name == NULL)
 			return -ENOMEM;
 		pr_debug("name:%s ", arg->name);
 		str = tmp + 1;
 	}
 	tmp = strchr(str, ':');
 	if (tmp) {	/* Type setting */
 		*tmp = '\0';
 		arg->type = strdup(tmp + 1);
 		if (arg->type == NULL)
 			return -ENOMEM;
 		pr_debug("type:%s ", arg->type);
 	}
 	tmp = strpbrk(str, "-.[");
 	if (!is_c_varname(str) || !tmp) {
 		/* A variable, register, symbol or special value */
 		arg->var = strdup(str);
 		if (arg->var == NULL)
 			return -ENOMEM;
 		pr_debug("%s\n", arg->var);
 		return 0;
 	}
 	/* Structure fields or array element */
 	arg->var = strndup(str, tmp - str);
 	if (arg->var == NULL)
 		return -ENOMEM;
 	goodname = arg->var;
 	pr_debug("%s, ", arg->var);
 	fieldp = &arg->field;
 	do {
 		*fieldp = zalloc(sizeof(struct perf_probe_arg_field));
 		if (*fieldp == NULL)
 			return -ENOMEM;
 		if (*tmp == '[') {	/* Array */
 			str = tmp;
 			(*fieldp)->index = strtol(str + 1, &tmp, 0);
 			(*fieldp)->ref = true;
 			if (*tmp != ']' || tmp == str + 1) {
 				semantic_error("Array index must be a"
 						" number.\n");
 				return -EINVAL;
 			}
 			tmp++;
 			if (*tmp == '\0')
 				tmp = NULL;
 		} else {		/* Structure */
 			if (*tmp == '.') {
 				str = tmp + 1;
 				(*fieldp)->ref = false;
 			} else if (tmp[1] == '>') {
 				str = tmp + 2;
 				(*fieldp)->ref = true;
 			} else {
 				semantic_error("Argument parse error: %s\n",
 					       str);
 				return -EINVAL;
 			}
 			tmp = strpbrk(str, "-.[");
 		}
 		if (tmp) {
 			(*fieldp)->name = strndup(str, tmp - str);
 			if ((*fieldp)->name == NULL)
 				return -ENOMEM;
 			if (*str != '[')
 				goodname = (*fieldp)->name;
 			pr_debug("%s(%d), ", (*fieldp)->name, (*fieldp)->ref);
 			fieldp = &(*fieldp)->next;
 		}
 	} while (tmp);
 	(*fieldp)->name = strdup(str);
 	if ((*fieldp)->name == NULL)
 		return -ENOMEM;
 	if (*str != '[')
 		goodname = (*fieldp)->name;
 	pr_debug("%s(%d)\n", (*fieldp)->name, (*fieldp)->ref);
 	/* If no name is specified, set the last field name (not array index)*/
 	if (!arg->name) {
 		arg->name = strdup(goodname);
 		if (arg->name == NULL)
 			return -ENOMEM;
 	}
 	return 0;
 }
 /* Parse perf-probe event command */
 int parse_perf_probe_command(const char *cmd, struct perf_probe_event *pev)
 {
 	char **argv;
 	int argc, i, ret = 0;
 	argv = argv_split(cmd, &argc);
 	if (!argv) {
 		pr_debug("Failed to split arguments.\n");
 		return -ENOMEM;
 	}
 	if (argc - 1 > MAX_PROBE_ARGS) {
 		semantic_error("Too many probe arguments (%d).\n", argc - 1);
 		ret = -ERANGE;
 		goto out;
 	}
 	/* Parse probe point */
 	ret = parse_perf_probe_point(argv[0], pev);
 	if (ret < 0)
 		goto out;
 	/* Copy arguments and ensure return probe has no C argument */
 	pev->nargs = argc - 1;
 	pev->args = zalloc(sizeof(struct perf_probe_arg) * pev->nargs);
 	if (pev->args == NULL) {
 		ret = -ENOMEM;
 		goto out;
 	}
 	for (i = 0; i < pev->nargs && ret >= 0; i++) {
 		ret = parse_perf_probe_arg(argv[i + 1], &pev->args[i]);
 		if (ret >= 0 &&
 		    is_c_varname(pev->args[i].var) && pev->point.retprobe) {
 			semantic_error("You can't specify local variable for"
 				       " kretprobe.\n");
 			ret = -EINVAL;
 		}
 	}
 out:
 	argv_free(argv);
 	return ret;
 }
 /* Return true if this perf_probe_event requires debuginfo */
 bool perf_probe_event_need_dwarf(struct perf_probe_event *pev)
 {
 	int i;
 	if (pev->point.file || pev->point.line || pev->point.lazy_line)
 		return true;
 	for (i = 0; i < pev->nargs; i++)
 		if (is_c_varname(pev->args[i].var))
 			return true;
 	return false;
 }
 /* Parse probe_events event into struct probe_point */
 static int parse_probe_trace_command(const char *cmd,
 				     struct probe_trace_event *tev)
 {
 	struct probe_trace_point *tp = &tev->point;
 	char pr;
 	char *p;
 	char *argv0_str = NULL, *fmt, *fmt1_str, *fmt2_str, *fmt3_str;
 	int ret, i, argc;
 	char **argv;
 	pr_debug("Parsing probe_events: %s\n", cmd);
 	argv = argv_split(cmd, &argc);
 	if (!argv) {
 		pr_debug("Failed to split arguments.\n");
 		return -ENOMEM;
 	}
 	if (argc < 2) {
 		semantic_error("Too few probe arguments.\n");
 		ret = -ERANGE;
 		goto out;
 	}
 	/* Scan event and group name. */
 	argv0_str = strdup(argv[0]);
 	if (argv0_str == NULL) {
 		ret = -ENOMEM;
 		goto out;
 	}
 	fmt1_str = strtok_r(argv0_str, ":", &fmt);
 	fmt2_str = strtok_r(NULL, "/", &fmt);
 	fmt3_str = strtok_r(NULL, " \t", &fmt);
 	if (fmt1_str == NULL || strlen(fmt1_str) != 1 || fmt2_str == NULL
 	    || fmt3_str == NULL) {
 		semantic_error("Failed to parse event name: %s\n", argv[0]);
 		ret = -EINVAL;
 		goto out;
 	}
 	pr = fmt1_str[0];
 	tev->group = strdup(fmt2_str);
 	tev->event = strdup(fmt3_str);
 	if (tev->group == NULL || tev->event == NULL) {
 		ret = -ENOMEM;
 		goto out;
 	}
 	pr_debug("Group:%s Event:%s probe:%c\n", tev->group, tev->event, pr);
 	tp->retprobe = (pr == 'r');
 	/* Scan module name(if there), function name and offset */
 	p = strchr(argv[1], ':');
 	if (p) {
 		tp->module = strndup(argv[1], p - argv[1]);
 		p++;
 	} else
 		p = argv[1];
 	fmt1_str = strtok_r(p, "+", &fmt);
 	if (fmt1_str[0] == '0')	/* only the address started with 0x */
 		tp->address = strtoul(fmt1_str, NULL, 0);
 	else {
 		/* Only the symbol-based probe has offset */
 		tp->symbol = strdup(fmt1_str);
 		if (tp->symbol == NULL) {
 			ret = -ENOMEM;
 			goto out;
 		}
 		fmt2_str = strtok_r(NULL, "", &fmt);
 		if (fmt2_str == NULL)
 			tp->offset = 0;
 		else
 			tp->offset = strtoul(fmt2_str, NULL, 10);
 	}
 	tev->nargs = argc - 2;
 	tev->args = zalloc(sizeof(struct probe_trace_arg) * tev->nargs);
 	if (tev->args == NULL) {
 		ret = -ENOMEM;
 		goto out;
 	}
 	for (i = 0; i < tev->nargs; i++) {
 		p = strchr(argv[i + 2], '=');
 		if (p)	/* We don't need which register is assigned. */
 			*p++ = '\0';
 		else
 			p = argv[i + 2];
 		tev->args[i].name = strdup(argv[i + 2]);
 		/* TODO: parse regs and offset */
 		tev->args[i].value = strdup(p);
 		if (tev->args[i].name == NULL || tev->args[i].value == NULL) {
 			ret = -ENOMEM;
 			goto out;
 		}
 	}
 	ret = 0;
 out:
 	free(argv0_str);
 	argv_free(argv);
 	return ret;
 }
 /* Compose only probe arg */
 int synthesize_perf_probe_arg(struct perf_probe_arg *pa, char *buf, size_t len)
 {
 	struct perf_probe_arg_field *field = pa->field;
 	int ret;
 	char *tmp = buf;
 	if (pa->name && pa->var)
 		ret = e_snprintf(tmp, len, "%s=%s", pa->name, pa->var);
 	else
 		ret = e_snprintf(tmp, len, "%s", pa->name ? pa->name : pa->var);
 	if (ret <= 0)
 		goto error;
 	tmp += ret;
 	len -= ret;
 	while (field) {
 		if (field->name[0] == '[')
 			ret = e_snprintf(tmp, len, "%s", field->name);
 		else
 			ret = e_snprintf(tmp, len, "%s%s",
 					 field->ref ? "->" : ".", field->name);
 		if (ret <= 0)
 			goto error;
 		tmp += ret;
 		len -= ret;
 		field = field->next;
 	}
 	if (pa->type) {
 		ret = e_snprintf(tmp, len, ":%s", pa->type);
 		if (ret <= 0)
 			goto error;
 		tmp += ret;
 		len -= ret;
 	}
 	return tmp - buf;
 error:
 	pr_debug("Failed to synthesize perf probe argument: %d\n", ret);
 	return ret;
 }
 /* Compose only probe point (not argument) */
 static char *synthesize_perf_probe_point(struct perf_probe_point *pp)
 {
 	char *buf, *tmp;
 	char offs[32] = "", line[32] = "", file[32] = "";
 	int ret, len;
 	buf = zalloc(MAX_CMDLEN);
 	if (buf == NULL) {
 		ret = -ENOMEM;
 		goto error;
 	}
 	if (pp->offset) {
 		ret = e_snprintf(offs, 32, "+%lu", pp->offset);
 		if (ret <= 0)
 			goto error;
 	}
 	if (pp->line) {
 		ret = e_snprintf(line, 32, ":%d", pp->line);
 		if (ret <= 0)
 			goto error;
 	}
 	if (pp->file) {
 		tmp = pp->file;
 		len = strlen(tmp);
 		if (len > 30) {
 			tmp = strchr(pp->file + len - 30, '/');
 			tmp = tmp ? tmp + 1 : pp->file + len - 30;
 		}
 		ret = e_snprintf(file, 32, "@%s", tmp);
 		if (ret <= 0)
 			goto error;
 	}
 	if (pp->function)
 		ret = e_snprintf(buf, MAX_CMDLEN, "%s%s%s%s%s", pp->function,
 				 offs, pp->retprobe ? "%return" : "", line,
 				 file);
 	else
 		ret = e_snprintf(buf, MAX_CMDLEN, "%s%s", file, line);
 	if (ret <= 0)
 		goto error;
 	return buf;
 error:
 	pr_debug("Failed to synthesize perf probe point: %d\n", ret);
 	free(buf);
 	return NULL;
 }
 #if 0
 char *synthesize_perf_probe_command(struct perf_probe_event *pev)
 {
 	char *buf;
 	int i, len, ret;
 	buf = synthesize_perf_probe_point(&pev->point);
 	if (!buf)
 		return NULL;
 	len = strlen(buf);
 	for (i = 0; i < pev->nargs; i++) {
 		ret = e_snprintf(&buf[len], MAX_CMDLEN - len, " %s",
 				 pev->args[i].name);
 		if (ret <= 0) {
 			free(buf);
 			return NULL;
 		}
 		len += ret;
 	}
 	return buf;
 }
 #endif
 static int __synthesize_probe_trace_arg_ref(struct probe_trace_arg_ref *ref,
 					     char **buf, size_t *buflen,
 					     int depth)
 {
 	int ret;
 	if (ref->next) {
 		depth = __synthesize_probe_trace_arg_ref(ref->next, buf,
 							 buflen, depth + 1);
 		if (depth < 0)
 			goto out;
 	}
 	ret = e_snprintf(*buf, *buflen, "%+ld(", ref->offset);
 	if (ret < 0)
 		depth = ret;
 	else {
 		*buf += ret;
 		*buflen -= ret;
 	}
 out:
 	return depth;
 }
 static int synthesize_probe_trace_arg(struct probe_trace_arg *arg,
 				       char *buf, size_t buflen)
 {
 	struct probe_trace_arg_ref *ref = arg->ref;
 	int ret, depth = 0;
 	char *tmp = buf;
 	/* Argument name or separator */
 	if (arg->name)
 		ret = e_snprintf(buf, buflen, " %s=", arg->name);
 	else
 		ret = e_snprintf(buf, buflen, " ");
 	if (ret < 0)
 		return ret;
 	buf += ret;
 	buflen -= ret;
 	/* Special case: @XXX */
 	if (arg->value[0] == '@' && arg->ref)
 			ref = ref->next;
 	/* Dereferencing arguments */
 	if (ref) {
 		depth = __synthesize_probe_trace_arg_ref(ref, &buf,
 							  &buflen, 1);
 		if (depth < 0)
 			return depth;
 	}
 	/* Print argument value */
 	if (arg->value[0] == '@' && arg->ref)
 		ret = e_snprintf(buf, buflen, "%s%+ld", arg->value,
 				 arg->ref->offset);
 	else
 		ret = e_snprintf(buf, buflen, "%s", arg->value);
 	if (ret < 0)
 		return ret;
 	buf += ret;
 	buflen -= ret;
 	/* Closing */
 	while (depth--) {
 		ret = e_snprintf(buf, buflen, ")");
 		if (ret < 0)
 			return ret;
 		buf += ret;
 		buflen -= ret;
 	}
 	/* Print argument type */
 	if (arg->type) {
 		ret = e_snprintf(buf, buflen, ":%s", arg->type);
 		if (ret <= 0)
 			return ret;
 		buf += ret;
 	}
 	return buf - tmp;
 }
 char *synthesize_probe_trace_command(struct probe_trace_event *tev)
 {
 	struct probe_trace_point *tp = &tev->point;
 	char *buf;
 	int i, len, ret;
 	buf = zalloc(MAX_CMDLEN);
 	if (buf == NULL)
 		return NULL;
 	len = e_snprintf(buf, MAX_CMDLEN, "%c:%s/%s ", tp->retprobe ? 'r' : 'p',
 			 tev->group, tev->event);
 	if (len <= 0)
 		goto error;
 	/* Uprobes must have tp->address and tp->module */
 	if (tev->uprobes && (!tp->address || !tp->module))
 		goto error;
 	/* Use the tp->address for uprobes */
 	if (tev->uprobes)
 		ret = e_snprintf(buf + len, MAX_CMDLEN - len, "%s:0x%lx",
 				 tp->module, tp->address);
 	else
 		ret = e_snprintf(buf + len, MAX_CMDLEN - len, "%s%s%s+%lu",
 				 tp->module ?: "", tp->module ? ":" : "",
 				 tp->symbol, tp->offset);
 	if (ret <= 0)
 		goto error;
 	len += ret;
 	for (i = 0; i < tev->nargs; i++) {
 		ret = synthesize_probe_trace_arg(&tev->args[i], buf + len,
 						  MAX_CMDLEN - len);
 		if (ret <= 0)
 			goto error;
 		len += ret;
 	}
 	return buf;
 error:
 	free(buf);
 	return NULL;
 }
 static int find_perf_probe_point_from_map(struct probe_trace_point *tp,
 					  struct perf_probe_point *pp,
 					  bool is_kprobe)
 {
 	struct symbol *sym = NULL;
 	struct map *map;
 	u64 addr;
 	int ret = -ENOENT;
 	if (!is_kprobe) {
 		map = dso__new_map(tp->module);
 		if (!map)
 			goto out;
 		addr = tp->address;
 		sym = map__find_symbol(map, addr, NULL);
 	} else {
 		addr = kernel_get_symbol_address_by_name(tp->symbol, true);
 		if (addr) {
 			addr += tp->offset;
 			sym = __find_kernel_function(addr, &map);
 		}
 	}
 	if (!sym)
 		goto out;
 	pp->retprobe = tp->retprobe;
 	pp->offset = addr - map->unmap_ip(map, sym->start);
 	pp->function = strdup(sym->name);
 	ret = pp->function ? 0 : -ENOMEM;
 out:
 	if (map && !is_kprobe) {
 		dso__delete(map->dso);
 		map__delete(map);
 	}
 	return ret;
 }
 static int convert_to_perf_probe_point(struct probe_trace_point *tp,
 					struct perf_probe_point *pp,
 					bool is_kprobe)
 {
 	char buf[128];
 	int ret;
 	ret = find_perf_probe_point_from_dwarf(tp, pp, is_kprobe);
 	if (!ret)
 		return 0;
 	ret = find_perf_probe_point_from_map(tp, pp, is_kprobe);
 	if (!ret)
 		return 0;
 	pr_debug("Failed to find probe point from both of dwarf and map.\n");
 	if (tp->symbol) {
 		pp->function = strdup(tp->symbol);
 		pp->offset = tp->offset;
 	} else if (!tp->module && !is_kprobe) {
 		ret = e_snprintf(buf, 128, "0x%" PRIx64, (u64)tp->address);
 		if (ret < 0)
 			return ret;
 		pp->function = strdup(buf);
 		pp->offset = 0;
 	}
 	if (pp->function == NULL)
 		return -ENOMEM;
 	pp->retprobe = tp->retprobe;
 	return 0;
 }
 static int convert_to_perf_probe_event(struct probe_trace_event *tev,
 			       struct perf_probe_event *pev, bool is_kprobe)
 {
 	char buf[64] = "";
 	int i, ret;
 	/* Convert event/group name */
 	pev->event = strdup(tev->event);
 	pev->group = strdup(tev->group);
 	if (pev->event == NULL || pev->group == NULL)
 		return -ENOMEM;
 	/* Convert trace_point to probe_point */
 	ret = convert_to_perf_probe_point(&tev->point, &pev->point, is_kprobe);
 	if (ret < 0)
 		return ret;
 	/* Convert trace_arg to probe_arg */
 	pev->nargs = tev->nargs;
 	pev->args = zalloc(sizeof(struct perf_probe_arg) * pev->nargs);
 	if (pev->args == NULL)
 		return -ENOMEM;
 	for (i = 0; i < tev->nargs && ret >= 0; i++) {
 		if (tev->args[i].name)
 			pev->args[i].name = strdup(tev->args[i].name);
 		else {
 			ret = synthesize_probe_trace_arg(&tev->args[i],
 							  buf, 64);
 			pev->args[i].name = strdup(buf);
 		}
 		if (pev->args[i].name == NULL && ret >= 0)
 			ret = -ENOMEM;
 	}
 	if (ret < 0)
 		clear_perf_probe_event(pev);
 	return ret;
 }
 void clear_perf_probe_event(struct perf_probe_event *pev)
 {
 	struct perf_probe_point *pp = &pev->point;
 	struct perf_probe_arg_field *field, *next;
 	int i;
 	free(pev->event);
 	free(pev->group);
 	free(pp->file);
 	free(pp->function);
 	free(pp->lazy_line);
 	for (i = 0; i < pev->nargs; i++) {
 		free(pev->args[i].name);
 		free(pev->args[i].var);
 		free(pev->args[i].type);
 		field = pev->args[i].field;
 		while (field) {
 			next = field->next;
 			zfree(&field->name);
 			free(field);
 			field = next;
 		}
 	}
 	free(pev->args);
 	memset(pev, 0, sizeof(*pev));
 }
 static void clear_probe_trace_event(struct probe_trace_event *tev)
 {
 	struct probe_trace_arg_ref *ref, *next;
 	int i;
 	free(tev->event);
 	free(tev->group);
 	free(tev->point.symbol);
 	free(tev->point.module);
 	for (i = 0; i < tev->nargs; i++) {
 		free(tev->args[i].name);
 		free(tev->args[i].value);
 		free(tev->args[i].type);
 		ref = tev->args[i].ref;
 		while (ref) {
 			next = ref->next;
 			free(ref);
 			ref = next;
 		}
 	}
 	free(tev->args);
 	memset(tev, 0, sizeof(*tev));
 }
 static void print_open_warning(int err, bool is_kprobe)
 {
 	char sbuf[STRERR_BUFSIZE];
 	if (err == -ENOENT) {
 		const char *config;
 		if (!is_kprobe)
 			config = "CONFIG_UPROBE_EVENTS";
 		else
 			config = "CONFIG_KPROBE_EVENTS";
 		pr_warning("%cprobe_events file does not exist"
 			   " - please rebuild kernel with %s.\n",
 			   is_kprobe ? 'k' : 'u', config);
 	} else if (err == -ENOTSUP)
 		pr_warning("Debugfs is not mounted.\n");
 	else
 		pr_warning("Failed to open %cprobe_events: %s\n",
 			   is_kprobe ? 'k' : 'u',
 			   strerror_r(-err, sbuf, sizeof(sbuf)));
 }
 static void print_both_open_warning(int kerr, int uerr)
 {
 	/* Both kprobes and uprobes are disabled, warn it. */
 	if (kerr == -ENOTSUP && uerr == -ENOTSUP)
 		pr_warning("Debugfs is not mounted.\n");
 	else if (kerr == -ENOENT && uerr == -ENOENT)
 		pr_warning("Please rebuild kernel with CONFIG_KPROBE_EVENTS "
 			   "or/and CONFIG_UPROBE_EVENTS.\n");
 	else {
 		char sbuf[STRERR_BUFSIZE];
 		pr_warning("Failed to open kprobe events: %s.\n",
 			   strerror_r(-kerr, sbuf, sizeof(sbuf)));
 		pr_warning("Failed to open uprobe events: %s.\n",
 			   strerror_r(-uerr, sbuf, sizeof(sbuf)));
 	}
 }
 static int open_probe_events(const char *trace_file, bool readwrite)
 {
 	char buf[PATH_MAX];
 	const char *__debugfs;
 	int ret;
 	__debugfs = debugfs_find_mountpoint();
 	if (__debugfs == NULL)
 		return -ENOTSUP;
 	ret = e_snprintf(buf, PATH_MAX, "%s/%s", __debugfs, trace_file);
 	if (ret >= 0) {
 		pr_debug("Opening %s write=%d\n", buf, readwrite);
 		if (readwrite && !probe_event_dry_run)
 			ret = open(buf, O_RDWR, O_APPEND);
 		else
 			ret = open(buf, O_RDONLY, 0);
 		if (ret < 0)
 			ret = -errno;
 	}
 	return ret;
 }
 static int open_kprobe_events(bool readwrite)
 {
 	return open_probe_events("tracing/kprobe_events", readwrite);
 }
 static int open_uprobe_events(bool readwrite)
 {
 	return open_probe_events("tracing/uprobe_events", readwrite);
 }
 /* Get raw string list of current kprobe_events  or uprobe_events */
 static struct strlist *get_probe_trace_command_rawlist(int fd)
 {
 	int ret, idx;
 	FILE *fp;
 	char buf[MAX_CMDLEN];
 	char *p;
 	struct strlist *sl;
 	sl = strlist__new(true, NULL);
 	fp = fdopen(dup(fd), "r");
 	while (!feof(fp)) {
 		p = fgets(buf, MAX_CMDLEN, fp);
 		if (!p)
 			break;
 		idx = strlen(p) - 1;
 		if (p[idx] == '\n')
 			p[idx] = '\0';
 		ret = strlist__add(sl, buf);
 		if (ret < 0) {
 			pr_debug("strlist__add failed (%d)\n", ret);
 			strlist__delete(sl);
 			return NULL;
 		}
 	}
 	fclose(fp);
 	return sl;
 }
 /* Show an event */
 static int show_perf_probe_event(struct perf_probe_event *pev,
 				 const char *module)
 {
 	int i, ret;
 	char buf[128];
 	char *place;
 	/* Synthesize only event probe point */
 	place = synthesize_perf_probe_point(&pev->point);
 	if (!place)
 		return -EINVAL;
 	ret = e_snprintf(buf, 128, "%s:%s", pev->group, pev->event);
 	if (ret < 0)
 		return ret;
 	pr_info("  %-20s (on %s", buf, place);
 	if (module)
 		pr_info(" in %s", module);
 	if (pev->nargs > 0) {
 		pr_info(" with");
 		for (i = 0; i < pev->nargs; i++) {
 			ret = synthesize_perf_probe_arg(&pev->args[i],
 							buf, 128);
 			if (ret < 0)
 				break;
 			pr_info(" %s", buf);
 		}
 	}
 	pr_info(")\n");
 	free(place);
 	return ret;
 }
 static int __show_perf_probe_events(int fd, bool is_kprobe)
 {
 	int ret = 0;
 	struct probe_trace_event tev;
 	struct perf_probe_event pev;
 	struct strlist *rawlist;
 	struct str_node *ent;
 	memset(&tev, 0, sizeof(tev));
 	memset(&pev, 0, sizeof(pev));
 	rawlist = get_probe_trace_command_rawlist(fd);
 	if (!rawlist)
 		return -ENOMEM;
 	strlist__for_each(ent, rawlist) {
 		ret = parse_probe_trace_command(ent->s, &tev);
 		if (ret >= 0) {
 			ret = convert_to_perf_probe_event(&tev, &pev,
 								is_kprobe);
 			if (ret >= 0)
 				ret = show_perf_probe_event(&pev,
 							    tev.point.module);
 		}
 		clear_perf_probe_event(&pev);
 		clear_probe_trace_event(&tev);
 		if (ret < 0)
 			break;
 	}
 	strlist__delete(rawlist);
 	return ret;
 }
 /* List up current perf-probe events */
 int show_perf_probe_events(void)
 {
 	int kp_fd, up_fd, ret;
 	setup_pager();
 	ret = init_symbol_maps(false);
 	if (ret < 0)
 		return ret;
 	kp_fd = open_kprobe_events(false);
 	if (kp_fd >= 0) {
 		ret = __show_perf_probe_events(kp_fd, true);
 		close(kp_fd);
 		if (ret < 0)
 			goto out;
 	}
 	up_fd = open_uprobe_events(false);
 	if (kp_fd < 0 && up_fd < 0) {
 		print_both_open_warning(kp_fd, up_fd);
 		ret = kp_fd;
 		goto out;
 	}
 	if (up_fd >= 0) {
 		ret = __show_perf_probe_events(up_fd, false);
 		close(up_fd);
 	}
 out:
 	exit_symbol_maps();
 	return ret;
 }
 /* Get current perf-probe event names */
 static struct strlist *get_probe_trace_event_names(int fd, bool include_group)
 {
 	char buf[128];
 	struct strlist *sl, *rawlist;
 	struct str_node *ent;
 	struct probe_trace_event tev;
 	int ret = 0;
 	memset(&tev, 0, sizeof(tev));
 	rawlist = get_probe_trace_command_rawlist(fd);
 	if (!rawlist)
 		return NULL;
 	sl = strlist__new(true, NULL);
 	strlist__for_each(ent, rawlist) {
 		ret = parse_probe_trace_command(ent->s, &tev);
 		if (ret < 0)
 			break;
 		if (include_group) {
 			ret = e_snprintf(buf, 128, "%s:%s", tev.group,
 					tev.event);
 			if (ret >= 0)
 				ret = strlist__add(sl, buf);
 		} else
 			ret = strlist__add(sl, tev.event);
 		clear_probe_trace_event(&tev);
 		if (ret < 0)
 			break;
 	}
 	strlist__delete(rawlist);
 	if (ret < 0) {
 		strlist__delete(sl);
 		return NULL;
 	}
 	return sl;
 }
 static int write_probe_trace_event(int fd, struct probe_trace_event *tev)
 {
 	int ret = 0;
 	char *buf = synthesize_probe_trace_command(tev);
 	char sbuf[STRERR_BUFSIZE];
 	if (!buf) {
 		pr_debug("Failed to synthesize probe trace event.\n");
 		return -EINVAL;
 	}
 	pr_debug("Writing event: %s\n", buf);
 	if (!probe_event_dry_run) {
 		ret = write(fd, buf, strlen(buf));
-		if (ret <= 0)
+		if (ret <= 0) {
+			ret = -errno;
 			pr_warning("Failed to write event: %s\n",
 				   strerror_r(errno, sbuf, sizeof(sbuf)));
+		}
 	}
 	free(buf);
 	return ret;
 }
 static int get_new_event_name(char *buf, size_t len, const char *base,
 			      struct strlist *namelist, bool allow_suffix)
 {
 	int i, ret;
 	/* Try no suffix */
 	ret = e_snprintf(buf, len, "%s", base);
 	if (ret < 0) {
 		pr_debug("snprintf() failed: %d\n", ret);
 		return ret;
 	}
 	if (!strlist__has_entry(namelist, buf))
 		return 0;
 	if (!allow_suffix) {
 		pr_warning("Error: event \"%s\" already exists. "
 			   "(Use -f to force duplicates.)\n", base);
 		return -EEXIST;
 	}
 	/* Try to add suffix */
 	for (i = 1; i < MAX_EVENT_INDEX; i++) {
 		ret = e_snprintf(buf, len, "%s_%d", base, i);
 		if (ret < 0) {
 			pr_debug("snprintf() failed: %d\n", ret);
 			return ret;
 		}
 		if (!strlist__has_entry(namelist, buf))
 			break;
 	}
 	if (i == MAX_EVENT_INDEX) {
 		pr_warning("Too many events are on the same function.\n");
 		ret = -ERANGE;
 	}
 	return ret;
 }
 static int __add_probe_trace_events(struct perf_probe_event *pev,
 				     struct probe_trace_event *tevs,
 				     int ntevs, bool allow_suffix)
 {
 	int i, fd, ret;
 	struct probe_trace_event *tev = NULL;
 	char buf[64];
 	const char *event, *group;
 	struct strlist *namelist;
 	if (pev->uprobes)
 		fd = open_uprobe_events(true);
 	else
 		fd = open_kprobe_events(true);
 	if (fd < 0) {
 		print_open_warning(fd, !pev->uprobes);
 		return fd;
 	}
 	/* Get current event names */
 	namelist = get_probe_trace_event_names(fd, false);
 	if (!namelist) {
 		pr_debug("Failed to get current event list.\n");
 		return -EIO;
 	}
 	ret = 0;
 	pr_info("Added new event%s\n", (ntevs > 1) ? "s:" : ":");
 	for (i = 0; i < ntevs; i++) {
 		tev = &tevs[i];
 		if (pev->event)
 			event = pev->event;
 		else
 			if (pev->point.function)
 				event = pev->point.function;
 			else
 				event = tev->point.symbol;
 		if (pev->group)
 			group = pev->group;
 		else
 			group = PERFPROBE_GROUP;
 		/* Get an unused new event name */
 		ret = get_new_event_name(buf, 64, event,
 					 namelist, allow_suffix);
 		if (ret < 0)
 			break;
 		event = buf;
 		tev->event = strdup(event);
 		tev->group = strdup(group);
 		if (tev->event == NULL || tev->group == NULL) {
 			ret = -ENOMEM;
 			break;
 		}
 		ret = write_probe_trace_event(fd, tev);
 		if (ret < 0)
 			break;
 		/* Add added event name to namelist */
 		strlist__add(namelist, event);
 		/* Trick here - save current event/group */
 		event = pev->event;
 		group = pev->group;
 		pev->event = tev->event;
 		pev->group = tev->group;
 		show_perf_probe_event(pev, tev->point.module);
 		/* Trick here - restore current event/group */
 		pev->event = (char *)event;
 		pev->group = (char *)group;
 		/*
 		 * Probes after the first probe which comes from same
 		 * user input are always allowed to add suffix, because
 		 * there might be several addresses corresponding to
 		 * one code line.
 		 */
 		allow_suffix = true;
 	}
 	if (ret >= 0) {
 		/* Show how to use the event. */
 		pr_info("\nYou can now use it in all perf tools, such as:\n\n");
 		pr_info("\tperf record -e %s:%s -aR sleep 1\n\n", tev->group,
 			 tev->event);
 	}
 	strlist__delete(namelist);
 	close(fd);
 	return ret;
 }
 static char *looking_function_name;
 static int num_matched_functions;
 static int probe_function_filter(struct map *map __maybe_unused,
 				      struct symbol *sym)
 {
 	if ((sym->binding == STB_GLOBAL || sym->binding == STB_LOCAL) &&
 	    strcmp(looking_function_name, sym->name) == 0) {
 		num_matched_functions++;
 		return 0;
 	}
 	return 1;
 }
 #define strdup_or_goto(str, label)	\
 	({ char *__p = strdup(str); if (!__p) goto label; __p; })
 /*
  * Find probe function addresses from map.
  * Return an error or the number of found probe_trace_event
  */
 static int find_probe_trace_events_from_map(struct perf_probe_event *pev,
 					    struct probe_trace_event **tevs,
 					    int max_tevs, const char *target)
 {
 	struct map *map = NULL;
 	struct kmap *kmap = NULL;
 	struct ref_reloc_sym *reloc_sym = NULL;
 	struct symbol *sym;
 	struct rb_node *nd;
 	struct probe_trace_event *tev;
 	struct perf_probe_point *pp = &pev->point;
 	struct probe_trace_point *tp;
 	int ret, i;
 	/* Init maps of given executable or kernel */
 	if (pev->uprobes)
 		map = dso__new_map(target);
 	else
 		map = kernel_get_module_map(target);
 	if (!map) {
 		ret = -EINVAL;
 		goto out;
 	}
 	/*
 	 * Load matched symbols: Since the different local symbols may have
 	 * same name but different addresses, this lists all the symbols.
 	 */
 	num_matched_functions = 0;
 	looking_function_name = pp->function;
 	ret = map__load(map, probe_function_filter);
 	if (ret || num_matched_functions == 0) {
 		pr_err("Failed to find symbol %s in %s\n", pp->function,
 			target ? : "kernel");
 		ret = -ENOENT;
 		goto out;
 	} else if (num_matched_functions > max_tevs) {
 		pr_err("Too many functions matched in %s\n",
 			target ? : "kernel");
 		ret = -E2BIG;
 		goto out;
 	}
 	if (!pev->uprobes) {
 		kmap = map__kmap(map);
 		reloc_sym = kmap->ref_reloc_sym;
 		if (!reloc_sym) {
 			pr_warning("Relocated base symbol is not found!\n");
 			ret = -EINVAL;
 			goto out;
 		}
 	}
 	/* Setup result trace-probe-events */
 	*tevs = zalloc(sizeof(*tev) * num_matched_functions);
 	if (!*tevs) {
 		ret = -ENOMEM;
 		goto out;
 	}
 	ret = 0;
 	map__for_each_symbol(map, sym, nd) {
 		tev = (*tevs) + ret;
 		tp = &tev->point;
 		if (ret == num_matched_functions) {
 			pr_warning("Too many symbols are listed. Skip it.\n");
 			break;
 		}
 		ret++;
 		if (pp->offset > sym->end - sym->start) {
 			pr_warning("Offset %ld is bigger than the size of %s\n",
 				   pp->offset, sym->name);
 			ret = -ENOENT;
 			goto err_out;
 		}
 		/* Add one probe point */
 		tp->address = map->unmap_ip(map, sym->start) + pp->offset;
 		if (reloc_sym) {
 			tp->symbol = strdup_or_goto(reloc_sym->name, nomem_out);
 			tp->offset = tp->address - reloc_sym->addr;
 		} else {
 			tp->symbol = strdup_or_goto(sym->name, nomem_out);
 			tp->offset = pp->offset;
 		}
 		tp->retprobe = pp->retprobe;
 		if (target)
 			tev->point.module = strdup_or_goto(target, nomem_out);
 		tev->uprobes = pev->uprobes;
 		tev->nargs = pev->nargs;
 		if (tev->nargs) {
 			tev->args = zalloc(sizeof(struct probe_trace_arg) *
 					   tev->nargs);
 			if (tev->args == NULL)
 				goto nomem_out;
 		}
 		for (i = 0; i < tev->nargs; i++) {
 			if (pev->args[i].name)
 				tev->args[i].name =
 					strdup_or_goto(pev->args[i].name,
 							nomem_out);
 			tev->args[i].value = strdup_or_goto(pev->args[i].var,
 							    nomem_out);
 			if (pev->args[i].type)
 				tev->args[i].type =
 					strdup_or_goto(pev->args[i].type,
 							nomem_out);
 		}
 	}
 out:
 	if (map && pev->uprobes) {
 		/* Only when using uprobe(exec) map needs to be released */
 		dso__delete(map->dso);
 		map__delete(map);
 	}
 	return ret;
 nomem_out:
 	ret = -ENOMEM;
 err_out:
 	clear_probe_trace_events(*tevs, num_matched_functions);
 	zfree(tevs);
 	goto out;
 }
 static int convert_to_probe_trace_events(struct perf_probe_event *pev,
 					  struct probe_trace_event **tevs,
 					  int max_tevs, const char *target)
 {
 	int ret;
 	if (pev->uprobes && !pev->group) {
 		/* Replace group name if not given */
 		ret = convert_exec_to_group(target, &pev->group);
 		if (ret != 0) {
 			pr_warning("Failed to make a group name.\n");
 			return ret;
 		}
 	}
 	/* Convert perf_probe_event with debuginfo */
 	ret = try_to_find_probe_trace_events(pev, tevs, max_tevs, target);
 	if (ret != 0)
 		return ret;	/* Found in debuginfo or got an error */
 	return find_probe_trace_events_from_map(pev, tevs, max_tevs, target);
 }
 struct __event_package {
 	struct perf_probe_event		*pev;
 	struct probe_trace_event	*tevs;
 	int				ntevs;
 };
 int add_perf_probe_events(struct perf_probe_event *pevs, int npevs,
 			  int max_tevs, const char *target, bool force_add)
 {
 	int i, j, ret;
 	struct __event_package *pkgs;
 	ret = 0;
 	pkgs = zalloc(sizeof(struct __event_package) * npevs);
 	if (pkgs == NULL)
 		return -ENOMEM;
 	ret = init_symbol_maps(pevs->uprobes);
 	if (ret < 0) {
 		free(pkgs);
 		return ret;
 	}
 	/* Loop 1: convert all events */
 	for (i = 0; i < npevs; i++) {
 		pkgs[i].pev = &pevs[i];
 		/* Convert with or without debuginfo */
 		ret  = convert_to_probe_trace_events(pkgs[i].pev,
 						     &pkgs[i].tevs,
 						     max_tevs,
 						     target);
 		if (ret < 0)
 			goto end;
 		pkgs[i].ntevs = ret;
 	}
 	/* Loop 2: add all events */
 	for (i = 0; i < npevs; i++) {
 		ret = __add_probe_trace_events(pkgs[i].pev, pkgs[i].tevs,
 						pkgs[i].ntevs, force_add);
 		if (ret < 0)
 			break;
 	}
 end:
 	/* Loop 3: cleanup and free trace events  */
 	for (i = 0; i < npevs; i++) {
 		for (j = 0; j < pkgs[i].ntevs; j++)
 			clear_probe_trace_event(&pkgs[i].tevs[j]);
 		zfree(&pkgs[i].tevs);
 	}
 	free(pkgs);
 	exit_symbol_maps();
 	return ret;
 }
 static int __del_trace_probe_event(int fd, struct str_node *ent)
 {
 	char *p;
 	char buf[128];
 	int ret;
 	/* Convert from perf-probe event to trace-probe event */
 	ret = e_snprintf(buf, 128, "-:%s", ent->s);
 	if (ret < 0)
 		goto error;
 	p = strchr(buf + 2, ':');
 	if (!p) {
 		pr_debug("Internal error: %s should have ':' but not.\n",
 			 ent->s);
 		ret = -ENOTSUP;
 		goto error;
 	}
 	*p = '/';
 	pr_debug("Writing event: %s\n", buf);
 	ret = write(fd, buf, strlen(buf));
 	if (ret < 0) {
 		ret = -errno;
 		goto error;
 	}
 	pr_info("Removed event: %s\n", ent->s);
 	return 0;
 error:
 	pr_warning("Failed to delete event: %s\n",
 		   strerror_r(-ret, buf, sizeof(buf)));
 	return ret;
 }
 static int del_trace_probe_event(int fd, const char *buf,
 						  struct strlist *namelist)
 {
 	struct str_node *ent, *n;
 	int ret = -1;
 	if (strpbrk(buf, "*?")) { /* Glob-exp */
 		strlist__for_each_safe(ent, n, namelist)
 			if (strglobmatch(ent->s, buf)) {
 				ret = __del_trace_probe_event(fd, ent);
 				if (ret < 0)
 					break;
 				strlist__remove(namelist, ent);
 			}
 	} else {
 		ent = strlist__find(namelist, buf);
 		if (ent) {
 			ret = __del_trace_probe_event(fd, ent);
 			if (ret >= 0)
 				strlist__remove(namelist, ent);
 		}
 	}
 	return ret;
 }
 int del_perf_probe_events(struct strlist *dellist)
 {
 	int ret = -1, ufd = -1, kfd = -1;
 	char buf[128];
 	const char *group, *event;
 	char *p, *str;
 	struct str_node *ent;
 	struct strlist *namelist = NULL, *unamelist = NULL;
 	/* Get current event names */
 	kfd = open_kprobe_events(true);
 	if (kfd >= 0)
 		namelist = get_probe_trace_event_names(kfd, true);
 	ufd = open_uprobe_events(true);
 	if (ufd >= 0)
 		unamelist = get_probe_trace_event_names(ufd, true);
 	if (kfd < 0 && ufd < 0) {
 		print_both_open_warning(kfd, ufd);
 		goto error;
 	}
 	if (namelist == NULL && unamelist == NULL)
 		goto error;
 	strlist__for_each(ent, dellist) {
 		str = strdup(ent->s);
 		if (str == NULL) {
 			ret = -ENOMEM;
 			goto error;
 		}
 		pr_debug("Parsing: %s\n", str);
 		p = strchr(str, ':');
 		if (p) {
 			group = str;
 			*p = '\0';
 			event = p + 1;
 		} else {
 			group = "*";
 			event = str;
 		}
 		ret = e_snprintf(buf, 128, "%s:%s", group, event);
 		if (ret < 0) {
 			pr_err("Failed to copy event.");
 			free(str);
 			goto error;
 		}
 		pr_debug("Group: %s, Event: %s\n", group, event);
 		if (namelist)
 			ret = del_trace_probe_event(kfd, buf, namelist);
 		if (unamelist && ret != 0)
 			ret = del_trace_probe_event(ufd, buf, unamelist);
 		if (ret != 0)
 			pr_info("Info: Event \"%s\" does not exist.\n", buf);
 		free(str);
 	}
 error:
 	if (kfd >= 0) {
 		strlist__delete(namelist);
 		close(kfd);
 	}
 	if (ufd >= 0) {
 		strlist__delete(unamelist);
 		close(ufd);
 	}
 	return ret;
 }
 /* TODO: don't use a global variable for filter ... */
 static struct strfilter *available_func_filter;
 /*
  * If a symbol corresponds to a function with global binding and
  * matches filter return 0. For all others return 1.
  */
 static int filter_available_functions(struct map *map __maybe_unused,
 				      struct symbol *sym)
 {
 	if ((sym->binding == STB_GLOBAL || sym->binding == STB_LOCAL) &&
 	    strfilter__compare(available_func_filter, sym->name))
 		return 0;
 	return 1;
 }
 int show_available_funcs(const char *target, struct strfilter *_filter,
 					bool user)
 {
 	struct map *map;
 	int ret;
 	ret = init_symbol_maps(user);
 	if (ret < 0)
 		return ret;
 	/* Get a symbol map */
 	if (user)
 		map = dso__new_map(target);
 	else
 		map = kernel_get_module_map(target);
 	if (!map) {
 		pr_err("Failed to get a map for %s\n", (target) ? : "kernel");
 		return -EINVAL;
 	}
 	/* Load symbols with given filter */
 	available_func_filter = _filter;
 	if (map__load(map, filter_available_functions)) {
 		pr_err("Failed to load symbols in %s\n", (target) ? : "kernel");
 		goto end;
 	}
 	if (!dso__sorted_by_name(map->dso, map->type))
 		dso__sort_by_name(map->dso, map->type);
 	/* Show all (filtered) symbols */
 	setup_pager();
 	dso__fprintf_symbols_by_name(map->dso, map->type, stdout);
 end:
 	if (user) {
 		dso__delete(map->dso);
 		map__delete(map);
 	}
 	exit_symbol_maps();
 	return ret;
 }

tools/perf/util/python-ext-sources

Diff comments View file @ 59b2858

1	#	1	#
2	# List of files needed by perf python extension	2	# List of files needed by perf python extension
3	#	3	#
4	# Each source file must be placed on its own line so that it can be	4	# Each source file must be placed on its own line so that it can be
5	# processed by Makefile and util/setup.py accordingly.	5	# processed by Makefile and util/setup.py accordingly.
6	#	6	#
7		7
8	util/python.c	8	util/python.c
9	util/ctype.c	9	util/ctype.c
10	util/evlist.c	10	util/evlist.c
11	util/evsel.c	11	util/evsel.c
12	util/cpumap.c	12	util/cpumap.c
13	util/hweight.c	13	../../lib/hweight.c
14	util/thread_map.c	14	util/thread_map.c
15	util/util.c	15	util/util.c
16	util/xyarray.c	16	util/xyarray.c
17	util/cgroup.c	17	util/cgroup.c
18	util/rblist.c	18	util/rblist.c
19	util/strlist.c	19	util/strlist.c
20	../lib/api/fs/fs.c	20	../lib/api/fs/fs.c
21	util/trace-event.c	21	util/trace-event.c
22	../../lib/rbtree.c	22	../../lib/rbtree.c
23		23

tools/perf/util/unwind-libunwind.c

Diff comments View file @ 59b2858

 /*
  * Post mortem Dwarf CFI based unwinding on top of regs and stack dumps.
  *
  * Lots of this code have been borrowed or heavily inspired from parts of
  * the libunwind 0.99 code which are (amongst other contributors I may have
  * forgotten):
  *
  * Copyright (C) 2002-2007 Hewlett-Packard Co
  *	Contributed by David Mosberger-Tang <davidm@hpl.hp.com>
  *
  * And the bugs have been added by:
  *
  * Copyright (C) 2010, Frederic Weisbecker <fweisbec@gmail.com>
  * Copyright (C) 2012, Jiri Olsa <jolsa@redhat.com>
  *
  */
 #include <elf.h>
 #include <gelf.h>
 #include <fcntl.h>
 #include <string.h>
 #include <unistd.h>
 #include <sys/mman.h>
 #include <linux/list.h>
 #include <libunwind.h>
 #include <libunwind-ptrace.h>
 #include "callchain.h"
 #include "thread.h"
 #include "session.h"
 #include "perf_regs.h"
 #include "unwind.h"
 #include "symbol.h"
 #include "util.h"
 #include "debug.h"
 extern int
 UNW_OBJ(dwarf_search_unwind_table) (unw_addr_space_t as,
 				    unw_word_t ip,
 				    unw_dyn_info_t *di,
 				    unw_proc_info_t *pi,
 				    int need_unwind_info, void *arg);
 #define dwarf_search_unwind_table UNW_OBJ(dwarf_search_unwind_table)
 extern int
 UNW_OBJ(dwarf_find_debug_frame) (int found, unw_dyn_info_t *di_debug,
 				 unw_word_t ip,
 				 unw_word_t segbase,
 				 const char *obj_name, unw_word_t start,
 				 unw_word_t end);
 #define dwarf_find_debug_frame UNW_OBJ(dwarf_find_debug_frame)
 #define DW_EH_PE_FORMAT_MASK	0x0f	/* format of the encoded value */
 #define DW_EH_PE_APPL_MASK	0x70	/* how the value is to be applied */
 /* Pointer-encoding formats: */
 #define DW_EH_PE_omit		0xff
 #define DW_EH_PE_ptr		0x00	/* pointer-sized unsigned value */
 #define DW_EH_PE_udata4		0x03	/* unsigned 32-bit value */
 #define DW_EH_PE_udata8		0x04	/* unsigned 64-bit value */
 #define DW_EH_PE_sdata4		0x0b	/* signed 32-bit value */
 #define DW_EH_PE_sdata8		0x0c	/* signed 64-bit value */
 /* Pointer-encoding application: */
 #define DW_EH_PE_absptr		0x00	/* absolute value */
 #define DW_EH_PE_pcrel		0x10	/* rel. to addr. of encoded value */
 /*
  * The following are not documented by LSB v1.3, yet they are used by
  * GCC, presumably they aren't documented by LSB since they aren't
  * used on Linux:
  */
 #define DW_EH_PE_funcrel	0x40	/* start-of-procedure-relative */
 #define DW_EH_PE_aligned	0x50	/* aligned pointer */
 /* Flags intentionaly not handled, since they're not needed:
  * #define DW_EH_PE_indirect      0x80
  * #define DW_EH_PE_uleb128       0x01
  * #define DW_EH_PE_udata2        0x02
  * #define DW_EH_PE_sleb128       0x09
  * #define DW_EH_PE_sdata2        0x0a
  * #define DW_EH_PE_textrel       0x20
  * #define DW_EH_PE_datarel       0x30
  */
 struct unwind_info {
 	struct perf_sample	*sample;
 	struct machine		*machine;
 	struct thread		*thread;
 };
 #define dw_read(ptr, type, end) ({	\
 	type *__p = (type *) ptr;	\
 	type  __v;			\
 	if ((__p + 1) > (type *) end)	\
 		return -EINVAL;		\
 	__v = *__p++;			\
 	ptr = (typeof(ptr)) __p;	\
 	__v;				\
 	})
 static int __dw_read_encoded_value(u8 **p, u8 *end, u64 *val,
 				   u8 encoding)
 {
 	u8 *cur = *p;
 	*val = 0;
 	switch (encoding) {
 	case DW_EH_PE_omit:
 		*val = 0;
 		goto out;
 	case DW_EH_PE_ptr:
 		*val = dw_read(cur, unsigned long, end);
 		goto out;
 	default:
 		break;
 	}
 	switch (encoding & DW_EH_PE_APPL_MASK) {
 	case DW_EH_PE_absptr:
 		break;
 	case DW_EH_PE_pcrel:
 		*val = (unsigned long) cur;
 		break;
 	default:
 		return -EINVAL;
 	}
 	if ((encoding & 0x07) == 0x00)
 		encoding |= DW_EH_PE_udata4;
 	switch (encoding & DW_EH_PE_FORMAT_MASK) {
 	case DW_EH_PE_sdata4:
 		*val += dw_read(cur, s32, end);
 		break;
 	case DW_EH_PE_udata4:
 		*val += dw_read(cur, u32, end);
 		break;
 	case DW_EH_PE_sdata8:
 		*val += dw_read(cur, s64, end);
 		break;
 	case DW_EH_PE_udata8:
 		*val += dw_read(cur, u64, end);
 		break;
 	default:
 		return -EINVAL;
 	}
  out:
 	*p = cur;
 	return 0;
 }
 #define dw_read_encoded_value(ptr, end, enc) ({			\
 	u64 __v;						\
 	if (__dw_read_encoded_value(&ptr, end, &__v, enc)) {	\
 		return -EINVAL;                                 \
 	}                                                       \
 	__v;                                                    \
 	})
 static u64 elf_section_offset(int fd, const char *name)
 {
 	Elf *elf;
 	GElf_Ehdr ehdr;
 	GElf_Shdr shdr;
 	u64 offset = 0;
 	elf = elf_begin(fd, PERF_ELF_C_READ_MMAP, NULL);
 	if (elf == NULL)
 		return 0;
 	do {
 		if (gelf_getehdr(elf, &ehdr) == NULL)
 			break;
 		if (!elf_section_by_name(elf, &ehdr, &shdr, name, NULL))
 			break;
 		offset = shdr.sh_offset;
 	} while (0);
 	elf_end(elf);
 	return offset;
 }
+#ifndef NO_LIBUNWIND_DEBUG_FRAME
+static int elf_is_exec(int fd, const char *name)
+{
+	Elf *elf;
+	GElf_Ehdr ehdr;
+	int retval = 0;
+	elf = elf_begin(fd, PERF_ELF_C_READ_MMAP, NULL);
+	if (elf == NULL)
+		return 0;
+	if (gelf_getehdr(elf, &ehdr) == NULL)
+		goto out;
+	retval = (ehdr.e_type == ET_EXEC);
+out:
+	elf_end(elf);
+	pr_debug("unwind: elf_is_exec(%s): %d\n", name, retval);
+	return retval;
+}
+#endif
 struct table_entry {
 	u32 start_ip_offset;
 	u32 fde_offset;
 };
 struct eh_frame_hdr {
 	unsigned char version;
 	unsigned char eh_frame_ptr_enc;
 	unsigned char fde_count_enc;
 	unsigned char table_enc;
 	/*
 	 * The rest of the header is variable-length and consists of the
 	 * following members:
 	 *
 	 *	encoded_t eh_frame_ptr;
 	 *	encoded_t fde_count;
 	 */
 	/* A single encoded pointer should not be more than 8 bytes. */
 	u64 enc[2];
 	/*
 	 * struct {
 	 *    encoded_t start_ip;
 	 *    encoded_t fde_addr;
 	 * } binary_search_table[fde_count];
 	 */
 	char data[0];
 } __packed;
 static int unwind_spec_ehframe(struct dso *dso, struct machine *machine,
 			       u64 offset, u64 *table_data, u64 *segbase,
 			       u64 *fde_count)
 {
 	struct eh_frame_hdr hdr;
 	u8 *enc = (u8 *) &hdr.enc;
 	u8 *end = (u8 *) &hdr.data;
 	ssize_t r;
 	r = dso__data_read_offset(dso, machine, offset,
 				  (u8 *) &hdr, sizeof(hdr));
 	if (r != sizeof(hdr))
 		return -EINVAL;
 	/* We dont need eh_frame_ptr, just skip it. */
 	dw_read_encoded_value(enc, end, hdr.eh_frame_ptr_enc);
 	*fde_count  = dw_read_encoded_value(enc, end, hdr.fde_count_enc);
 	*segbase    = offset;
 	*table_data = (enc - (u8 *) &hdr) + offset;
 	return 0;
 }
 static int read_unwind_spec_eh_frame(struct dso *dso, struct machine *machine,
 				     u64 *table_data, u64 *segbase,
 				     u64 *fde_count)
 {
 	int ret = -EINVAL, fd;
 	u64 offset;
 	fd = dso__data_fd(dso, machine);
 	if (fd < 0)
 		return -EINVAL;
 	/* Check the .eh_frame section for unwinding info */
 	offset = elf_section_offset(fd, ".eh_frame_hdr");
 	if (offset)
 		ret = unwind_spec_ehframe(dso, machine, offset,
 					  table_data, segbase,
 					  fde_count);
 	return ret;
 }
 #ifndef NO_LIBUNWIND_DEBUG_FRAME
 static int read_unwind_spec_debug_frame(struct dso *dso,
 					struct machine *machine, u64 *offset)
 {
 	int fd = dso__data_fd(dso, machine);
 	if (fd < 0)
 		return -EINVAL;
 	/* Check the .debug_frame section for unwinding info */
 	*offset = elf_section_offset(fd, ".debug_frame");
 	if (*offset)
 		return 0;
 	return -EINVAL;
 }
 #endif
 static struct map *find_map(unw_word_t ip, struct unwind_info *ui)
 {
 	struct addr_location al;
 	thread__find_addr_map(ui->thread, PERF_RECORD_MISC_USER,
 			      MAP__FUNCTION, ip, &al);
 	return al.map;
 }
 static int
 find_proc_info(unw_addr_space_t as, unw_word_t ip, unw_proc_info_t *pi,
 	       int need_unwind_info, void *arg)
 {
 	struct unwind_info *ui = arg;
 	struct map *map;
 	unw_dyn_info_t di;
 	u64 table_data, segbase, fde_count;
 	map = find_map(ip, ui);
 	if (!map || !map->dso)
 		return -EINVAL;
 	pr_debug("unwind: find_proc_info dso %s\n", map->dso->name);
 	/* Check the .eh_frame section for unwinding info */
 	if (!read_unwind_spec_eh_frame(map->dso, ui->machine,
 				       &table_data, &segbase, &fde_count)) {
 		memset(&di, 0, sizeof(di));
 		di.format   = UNW_INFO_FORMAT_REMOTE_TABLE;
 		di.start_ip = map->start;
 		di.end_ip   = map->end;
 		di.u.rti.segbase    = map->start + segbase;
 		di.u.rti.table_data = map->start + table_data;
 		di.u.rti.table_len  = fde_count * sizeof(struct table_entry)
 				      / sizeof(unw_word_t);
 		return dwarf_search_unwind_table(as, ip, &di, pi,
 						 need_unwind_info, arg);
 	}
 #ifndef NO_LIBUNWIND_DEBUG_FRAME
 	/* Check the .debug_frame section for unwinding info */
 	if (!read_unwind_spec_debug_frame(map->dso, ui->machine, &segbase)) {
+		int fd = dso__data_fd(map->dso, ui->machine);
+		int is_exec = elf_is_exec(fd, map->dso->name);
+		unw_word_t base = is_exec ? 0 : map->start;
 		memset(&di, 0, sizeof(di));
-		if (dwarf_find_debug_frame(0, &di, ip, 0, map->dso->name,
+		if (dwarf_find_debug_frame(0, &di, ip, base, map->dso->name,
 					   map->start, map->end))
 			return dwarf_search_unwind_table(as, ip, &di, pi,
 							 need_unwind_info, arg);
 	}
 #endif
 	return -EINVAL;
 }
 static int access_fpreg(unw_addr_space_t __maybe_unused as,
 			unw_regnum_t __maybe_unused num,
 			unw_fpreg_t __maybe_unused *val,
 			int __maybe_unused __write,
 			void __maybe_unused *arg)
 {
 	pr_err("unwind: access_fpreg unsupported\n");
 	return -UNW_EINVAL;
 }
 static int get_dyn_info_list_addr(unw_addr_space_t __maybe_unused as,
 				  unw_word_t __maybe_unused *dil_addr,
 				  void __maybe_unused *arg)
 {
 	return -UNW_ENOINFO;
 }
 static int resume(unw_addr_space_t __maybe_unused as,
 		  unw_cursor_t __maybe_unused *cu,
 		  void __maybe_unused *arg)
 {
 	pr_err("unwind: resume unsupported\n");
 	return -UNW_EINVAL;
 }
 static int
 get_proc_name(unw_addr_space_t __maybe_unused as,
 	      unw_word_t __maybe_unused addr,
 		char __maybe_unused *bufp, size_t __maybe_unused buf_len,
 		unw_word_t __maybe_unused *offp, void __maybe_unused *arg)
 {
 	pr_err("unwind: get_proc_name unsupported\n");
 	return -UNW_EINVAL;
 }
 static int access_dso_mem(struct unwind_info *ui, unw_word_t addr,
 			  unw_word_t *data)
 {
 	struct addr_location al;
 	ssize_t size;
 	thread__find_addr_map(ui->thread, PERF_RECORD_MISC_USER,
 			      MAP__FUNCTION, addr, &al);
 	if (!al.map) {
 		pr_debug("unwind: no map for %lx\n", (unsigned long)addr);
 		return -1;
 	}
 	if (!al.map->dso)
 		return -1;
 	size = dso__data_read_addr(al.map->dso, al.map, ui->machine,
 				   addr, (u8 *) data, sizeof(*data));
 	return !(size == sizeof(*data));
 }
 static int access_mem(unw_addr_space_t __maybe_unused as,
 		      unw_word_t addr, unw_word_t *valp,
 		      int __write, void *arg)
 {
 	struct unwind_info *ui = arg;
 	struct stack_dump *stack = &ui->sample->user_stack;
 	u64 start, end;
 	int offset;
 	int ret;
 	/* Don't support write, probably not needed. */
 	if (__write || !stack || !ui->sample->user_regs.regs) {
 		*valp = 0;
 		return 0;
 	}
 	ret = perf_reg_value(&start, &ui->sample->user_regs, PERF_REG_SP);
 	if (ret)
 		return ret;
 	end = start + stack->size;
 	/* Check overflow. */
 	if (addr + sizeof(unw_word_t) < addr)
 		return -EINVAL;
 	if (addr < start || addr + sizeof(unw_word_t) >= end) {
 		ret = access_dso_mem(ui, addr, valp);
 		if (ret) {
 			pr_debug("unwind: access_mem %p not inside range"
 				 " 0x%" PRIx64 "-0x%" PRIx64 "\n",
 				 (void *) addr, start, end);
 			*valp = 0;
 			return ret;
 		}
 		return 0;
 	}
 	offset = addr - start;
 	*valp  = *(unw_word_t *)&stack->data[offset];
 	pr_debug("unwind: access_mem addr %p val %lx, offset %d\n",
 		 (void *) addr, (unsigned long)*valp, offset);
 	return 0;
 }
 static int access_reg(unw_addr_space_t __maybe_unused as,
 		      unw_regnum_t regnum, unw_word_t *valp,
 		      int __write, void *arg)
 {
 	struct unwind_info *ui = arg;
 	int id, ret;
 	u64 val;
 	/* Don't support write, I suspect we don't need it. */
 	if (__write) {
 		pr_err("unwind: access_reg w %d\n", regnum);
 		return 0;
 	}
 	if (!ui->sample->user_regs.regs) {
 		*valp = 0;
 		return 0;
 	}
 	id = libunwind__arch_reg_id(regnum);
 	if (id < 0)
 		return -EINVAL;
 	ret = perf_reg_value(&val, &ui->sample->user_regs, id);
 	if (ret) {
 		pr_err("unwind: can't read reg %d\n", regnum);
 		return ret;
 	}
 	*valp = (unw_word_t) val;
 	pr_debug("unwind: reg %d, val %lx\n", regnum, (unsigned long)*valp);
 	return 0;
 }
 static void put_unwind_info(unw_addr_space_t __maybe_unused as,
 			    unw_proc_info_t *pi __maybe_unused,
 			    void *arg __maybe_unused)
 {
 	pr_debug("unwind: put_unwind_info called\n");
 }
 static int entry(u64 ip, struct thread *thread,
 		 unwind_entry_cb_t cb, void *arg)
 {
 	struct unwind_entry e;
 	struct addr_location al;
 	thread__find_addr_location(thread, PERF_RECORD_MISC_USER,
 				   MAP__FUNCTION, ip, &al);
 	e.ip = ip;
 	e.map = al.map;
 	e.sym = al.sym;
 	pr_debug("unwind: %s:ip = 0x%" PRIx64 " (0x%" PRIx64 ")\n",
 		 al.sym ? al.sym->name : "''",
 		 ip,
 		 al.map ? al.map->map_ip(al.map, ip) : (u64) 0);
 	return cb(&e, arg);
 }
 static void display_error(int err)
 {
 	switch (err) {
 	case UNW_EINVAL:
 		pr_err("unwind: Only supports local.\n");
 		break;
 	case UNW_EUNSPEC:
 		pr_err("unwind: Unspecified error.\n");
 		break;
 	case UNW_EBADREG:
 		pr_err("unwind: Register unavailable.\n");
 		break;
 	default:
 		break;
 	}
 }
 static unw_accessors_t accessors = {
 	.find_proc_info		= find_proc_info,
 	.put_unwind_info	= put_unwind_info,
 	.get_dyn_info_list_addr	= get_dyn_info_list_addr,
 	.access_mem		= access_mem,
 	.access_reg		= access_reg,
 	.access_fpreg		= access_fpreg,
 	.resume			= resume,
 	.get_proc_name		= get_proc_name,
 };
 int unwind__prepare_access(struct thread *thread)
 {
 	unw_addr_space_t addr_space;
 	if (callchain_param.record_mode != CALLCHAIN_DWARF)
 		return 0;
 	addr_space = unw_create_addr_space(&accessors, 0);
 	if (!addr_space) {
 		pr_err("unwind: Can't create unwind address space.\n");
 		return -ENOMEM;
 	}
 	unw_set_caching_policy(addr_space, UNW_CACHE_GLOBAL);
 	thread__set_priv(thread, addr_space);
 	return 0;
 }
 void unwind__flush_access(struct thread *thread)
 {
 	unw_addr_space_t addr_space;
 	if (callchain_param.record_mode != CALLCHAIN_DWARF)
 		return;
 	addr_space = thread__priv(thread);
 	unw_flush_cache(addr_space, 0, 0);
 }
 void unwind__finish_access(struct thread *thread)
 {
 	unw_addr_space_t addr_space;
 	if (callchain_param.record_mode != CALLCHAIN_DWARF)
 		return;
 	addr_space = thread__priv(thread);
 	unw_destroy_addr_space(addr_space);
 }
 static int get_entries(struct unwind_info *ui, unwind_entry_cb_t cb,
 		       void *arg, int max_stack)
 {
 	unw_addr_space_t addr_space;
 	unw_cursor_t c;
 	int ret;
 	addr_space = thread__priv(ui->thread);
 	if (addr_space == NULL)
 		return -1;
 	ret = unw_init_remote(&c, addr_space, ui);
 	if (ret)
 		display_error(ret);
 	while (!ret && (unw_step(&c) > 0) && max_stack--) {
 		unw_word_t ip;
 		unw_get_reg(&c, UNW_REG_IP, &ip);
 		ret = ip ? entry(ip, ui->thread, cb, arg) : 0;
 	}
 	return ret;
 }
 int unwind__get_entries(unwind_entry_cb_t cb, void *arg,
 			struct thread *thread,
 			struct perf_sample *data, int max_stack)
 {
 	u64 ip;
 	struct unwind_info ui = {
 		.sample       = data,
 		.thread       = thread,
 		.machine      = thread->mg->machine,
 	};
 	int ret;
 	if (!data->user_regs.regs)
 		return -EINVAL;
 	ret = perf_reg_value(&ip, &data->user_regs, PERF_REG_IP);
 	if (ret)
 		return ret;
 	ret = entry(ip, thread, cb, arg);
 	if (ret)
 		return -ENOMEM;
 	return --max_stack > 0 ? get_entries(&ui, cb, arg, max_stack) : 0;
 }