Eric Lee / linux-smarc-t335x-v3.2

Commit 1d229d54dbc26971142f61c3d271a68db236d178

Authored by Linus Torvalds 2011-08-12 00:03:48 +0800

Exists in master and in 4 other branches

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

…l/git/tip/linux-2.6-tip

* 'perf-urgent-for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/tip/linux-2.6-tip:
  perf symbols: Check '/tmp/perf-' symbol file ownership
  perf sched: Usage leftover from trace -> script rename
  perf sched: Do not delete session object prematurely
  perf tools: Check $HOME/.perfconfig ownership
  perf, x86: Add model 45 SandyBridge support
  perf tools: Add support to install perf python extension
  perf tools: do not look at ./config for configuration
  perf tools: Make clean leaves some files
  perf lock: Dropping unsupported ':r' modifier
  perf probe: Fix coredump introduced by probe module option
  jump label: Reduce the cycle count by changing the link order
  perf report: Use ui__warning in some more places
  perf python: Add PERF_RECORD_{LOST,READ,SAMPLE} routine tables
  perf evlist: Introduce 'disable' method
  trace events: Update version number reference to new 3.x scheme for EVENT_POWER_TRACING_DEPRECATED
  perf buildid-cache: Zero out buffer of filenames when adding/removing buildid

Showing 16 changed files Inline Diff

arch/x86/kernel/cpu/perf_event_intel.c
kernel/Makefile
kernel/trace/Kconfig
tools/perf/Makefile
tools/perf/builtin-lock.c
tools/perf/builtin-record.c
tools/perf/builtin-report.c
tools/perf/builtin-sched.c
tools/perf/util/config.c
tools/perf/util/evlist.c
tools/perf/util/evlist.h
tools/perf/util/header.c
tools/perf/util/probe-event.c
tools/perf/util/python.c
tools/perf/util/setup.py
tools/perf/util/symbol.c

arch/x86/kernel/cpu/perf_event_intel.c

Diff comments View file @ 1d229d5

 #ifdef CONFIG_CPU_SUP_INTEL
 /*
  * Per core/cpu state
  *
  * Used to coordinate shared registers between HT threads or
  * among events on a single PMU.
  */
 struct intel_shared_regs {
 	struct er_account       regs[EXTRA_REG_MAX];
 	int                     refcnt;		/* per-core: #HT threads */
 	unsigned                core_id;	/* per-core: core id */
 };
 /*
  * Intel PerfMon, used on Core and later.
  */
 static u64 intel_perfmon_event_map[PERF_COUNT_HW_MAX] __read_mostly =
 {
   [PERF_COUNT_HW_CPU_CYCLES]		= 0x003c,
   [PERF_COUNT_HW_INSTRUCTIONS]		= 0x00c0,
   [PERF_COUNT_HW_CACHE_REFERENCES]	= 0x4f2e,
   [PERF_COUNT_HW_CACHE_MISSES]		= 0x412e,
   [PERF_COUNT_HW_BRANCH_INSTRUCTIONS]	= 0x00c4,
   [PERF_COUNT_HW_BRANCH_MISSES]		= 0x00c5,
   [PERF_COUNT_HW_BUS_CYCLES]		= 0x013c,
 };
 static struct event_constraint intel_core_event_constraints[] __read_mostly =
 {
 	INTEL_EVENT_CONSTRAINT(0x11, 0x2), /* FP_ASSIST */
 	INTEL_EVENT_CONSTRAINT(0x12, 0x2), /* MUL */
 	INTEL_EVENT_CONSTRAINT(0x13, 0x2), /* DIV */
 	INTEL_EVENT_CONSTRAINT(0x14, 0x1), /* CYCLES_DIV_BUSY */
 	INTEL_EVENT_CONSTRAINT(0x19, 0x2), /* DELAYED_BYPASS */
 	INTEL_EVENT_CONSTRAINT(0xc1, 0x1), /* FP_COMP_INSTR_RET */
 	EVENT_CONSTRAINT_END
 };
 static struct event_constraint intel_core2_event_constraints[] __read_mostly =
 {
 	FIXED_EVENT_CONSTRAINT(0x00c0, 0), /* INST_RETIRED.ANY */
 	FIXED_EVENT_CONSTRAINT(0x003c, 1), /* CPU_CLK_UNHALTED.CORE */
 	/*
 	 * Core2 has Fixed Counter 2 listed as CPU_CLK_UNHALTED.REF and event
 	 * 0x013c as CPU_CLK_UNHALTED.BUS and specifies there is a fixed
 	 * ratio between these counters.
 	 */
 	/* FIXED_EVENT_CONSTRAINT(0x013c, 2),  CPU_CLK_UNHALTED.REF */
 	INTEL_EVENT_CONSTRAINT(0x10, 0x1), /* FP_COMP_OPS_EXE */
 	INTEL_EVENT_CONSTRAINT(0x11, 0x2), /* FP_ASSIST */
 	INTEL_EVENT_CONSTRAINT(0x12, 0x2), /* MUL */
 	INTEL_EVENT_CONSTRAINT(0x13, 0x2), /* DIV */
 	INTEL_EVENT_CONSTRAINT(0x14, 0x1), /* CYCLES_DIV_BUSY */
 	INTEL_EVENT_CONSTRAINT(0x18, 0x1), /* IDLE_DURING_DIV */
 	INTEL_EVENT_CONSTRAINT(0x19, 0x2), /* DELAYED_BYPASS */
 	INTEL_EVENT_CONSTRAINT(0xa1, 0x1), /* RS_UOPS_DISPATCH_CYCLES */
 	INTEL_EVENT_CONSTRAINT(0xc9, 0x1), /* ITLB_MISS_RETIRED (T30-9) */
 	INTEL_EVENT_CONSTRAINT(0xcb, 0x1), /* MEM_LOAD_RETIRED */
 	EVENT_CONSTRAINT_END
 };
 static struct event_constraint intel_nehalem_event_constraints[] __read_mostly =
 {
 	FIXED_EVENT_CONSTRAINT(0x00c0, 0), /* INST_RETIRED.ANY */
 	FIXED_EVENT_CONSTRAINT(0x003c, 1), /* CPU_CLK_UNHALTED.CORE */
 	/* FIXED_EVENT_CONSTRAINT(0x013c, 2), CPU_CLK_UNHALTED.REF */
 	INTEL_EVENT_CONSTRAINT(0x40, 0x3), /* L1D_CACHE_LD */
 	INTEL_EVENT_CONSTRAINT(0x41, 0x3), /* L1D_CACHE_ST */
 	INTEL_EVENT_CONSTRAINT(0x42, 0x3), /* L1D_CACHE_LOCK */
 	INTEL_EVENT_CONSTRAINT(0x43, 0x3), /* L1D_ALL_REF */
 	INTEL_EVENT_CONSTRAINT(0x48, 0x3), /* L1D_PEND_MISS */
 	INTEL_EVENT_CONSTRAINT(0x4e, 0x3), /* L1D_PREFETCH */
 	INTEL_EVENT_CONSTRAINT(0x51, 0x3), /* L1D */
 	INTEL_EVENT_CONSTRAINT(0x63, 0x3), /* CACHE_LOCK_CYCLES */
 	EVENT_CONSTRAINT_END
 };
 static struct extra_reg intel_nehalem_extra_regs[] __read_mostly =
 {
 	INTEL_EVENT_EXTRA_REG(0xb7, MSR_OFFCORE_RSP_0, 0xffff, RSP_0),
 	EVENT_EXTRA_END
 };
 static struct event_constraint intel_westmere_event_constraints[] __read_mostly =
 {
 	FIXED_EVENT_CONSTRAINT(0x00c0, 0), /* INST_RETIRED.ANY */
 	FIXED_EVENT_CONSTRAINT(0x003c, 1), /* CPU_CLK_UNHALTED.CORE */
 	/* FIXED_EVENT_CONSTRAINT(0x013c, 2), CPU_CLK_UNHALTED.REF */
 	INTEL_EVENT_CONSTRAINT(0x51, 0x3), /* L1D */
 	INTEL_EVENT_CONSTRAINT(0x60, 0x1), /* OFFCORE_REQUESTS_OUTSTANDING */
 	INTEL_EVENT_CONSTRAINT(0x63, 0x3), /* CACHE_LOCK_CYCLES */
 	INTEL_EVENT_CONSTRAINT(0xb3, 0x1), /* SNOOPQ_REQUEST_OUTSTANDING */
 	EVENT_CONSTRAINT_END
 };
 static struct event_constraint intel_snb_event_constraints[] __read_mostly =
 {
 	FIXED_EVENT_CONSTRAINT(0x00c0, 0), /* INST_RETIRED.ANY */
 	FIXED_EVENT_CONSTRAINT(0x003c, 1), /* CPU_CLK_UNHALTED.CORE */
 	/* FIXED_EVENT_CONSTRAINT(0x013c, 2), CPU_CLK_UNHALTED.REF */
 	INTEL_EVENT_CONSTRAINT(0x48, 0x4), /* L1D_PEND_MISS.PENDING */
 	INTEL_UEVENT_CONSTRAINT(0x01c0, 0x2), /* INST_RETIRED.PREC_DIST */
 	INTEL_EVENT_CONSTRAINT(0xcd, 0x8), /* MEM_TRANS_RETIRED.LOAD_LATENCY */
 	EVENT_CONSTRAINT_END
 };
 static struct extra_reg intel_westmere_extra_regs[] __read_mostly =
 {
 	INTEL_EVENT_EXTRA_REG(0xb7, MSR_OFFCORE_RSP_0, 0xffff, RSP_0),
 	INTEL_EVENT_EXTRA_REG(0xbb, MSR_OFFCORE_RSP_1, 0xffff, RSP_1),
 	EVENT_EXTRA_END
 };
 static struct event_constraint intel_v1_event_constraints[] __read_mostly =
 {
 	EVENT_CONSTRAINT_END
 };
 static struct event_constraint intel_gen_event_constraints[] __read_mostly =
 {
 	FIXED_EVENT_CONSTRAINT(0x00c0, 0), /* INST_RETIRED.ANY */
 	FIXED_EVENT_CONSTRAINT(0x003c, 1), /* CPU_CLK_UNHALTED.CORE */
 	/* FIXED_EVENT_CONSTRAINT(0x013c, 2), CPU_CLK_UNHALTED.REF */
 	EVENT_CONSTRAINT_END
 };
 static struct extra_reg intel_snb_extra_regs[] __read_mostly = {
 	INTEL_EVENT_EXTRA_REG(0xb7, MSR_OFFCORE_RSP_0, 0x3fffffffffull, RSP_0),
 	INTEL_EVENT_EXTRA_REG(0xbb, MSR_OFFCORE_RSP_1, 0x3fffffffffull, RSP_1),
 	EVENT_EXTRA_END
 };
 static u64 intel_pmu_event_map(int hw_event)
 {
 	return intel_perfmon_event_map[hw_event];
 }
 static __initconst const u64 snb_hw_cache_event_ids
 				[PERF_COUNT_HW_CACHE_MAX]
 				[PERF_COUNT_HW_CACHE_OP_MAX]
 				[PERF_COUNT_HW_CACHE_RESULT_MAX] =
 {
  [ C(L1D) ] = {
 	[ C(OP_READ) ] = {
 		[ C(RESULT_ACCESS) ] = 0xf1d0, /* MEM_UOP_RETIRED.LOADS        */
 		[ C(RESULT_MISS)   ] = 0x0151, /* L1D.REPLACEMENT              */
 	},
 	[ C(OP_WRITE) ] = {
 		[ C(RESULT_ACCESS) ] = 0xf2d0, /* MEM_UOP_RETIRED.STORES       */
 		[ C(RESULT_MISS)   ] = 0x0851, /* L1D.ALL_M_REPLACEMENT        */
 	},
 	[ C(OP_PREFETCH) ] = {
 		[ C(RESULT_ACCESS) ] = 0x0,
 		[ C(RESULT_MISS)   ] = 0x024e, /* HW_PRE_REQ.DL1_MISS          */
 	},
  },
  [ C(L1I ) ] = {
 	[ C(OP_READ) ] = {
 		[ C(RESULT_ACCESS) ] = 0x0,
 		[ C(RESULT_MISS)   ] = 0x0280, /* ICACHE.MISSES */
 	},
 	[ C(OP_WRITE) ] = {
 		[ C(RESULT_ACCESS) ] = -1,
 		[ C(RESULT_MISS)   ] = -1,
 	},
 	[ C(OP_PREFETCH) ] = {
 		[ C(RESULT_ACCESS) ] = 0x0,
 		[ C(RESULT_MISS)   ] = 0x0,
 	},
  },
  [ C(LL  ) ] = {
 	[ C(OP_READ) ] = {
 		/* OFFCORE_RESPONSE.ANY_DATA.LOCAL_CACHE */
 		[ C(RESULT_ACCESS) ] = 0x01b7,
 		/* OFFCORE_RESPONSE.ANY_DATA.ANY_LLC_MISS */
 		[ C(RESULT_MISS)   ] = 0x01b7,
 	},
 	[ C(OP_WRITE) ] = {
 		/* OFFCORE_RESPONSE.ANY_RFO.LOCAL_CACHE */
 		[ C(RESULT_ACCESS) ] = 0x01b7,
 		/* OFFCORE_RESPONSE.ANY_RFO.ANY_LLC_MISS */
 		[ C(RESULT_MISS)   ] = 0x01b7,
 	},
 	[ C(OP_PREFETCH) ] = {
 		/* OFFCORE_RESPONSE.PREFETCH.LOCAL_CACHE */
 		[ C(RESULT_ACCESS) ] = 0x01b7,
 		/* OFFCORE_RESPONSE.PREFETCH.ANY_LLC_MISS */
 		[ C(RESULT_MISS)   ] = 0x01b7,
 	},
  },
  [ C(DTLB) ] = {
 	[ C(OP_READ) ] = {
 		[ C(RESULT_ACCESS) ] = 0x81d0, /* MEM_UOP_RETIRED.ALL_LOADS */
 		[ C(RESULT_MISS)   ] = 0x0108, /* DTLB_LOAD_MISSES.CAUSES_A_WALK */
 	},
 	[ C(OP_WRITE) ] = {
 		[ C(RESULT_ACCESS) ] = 0x82d0, /* MEM_UOP_RETIRED.ALL_STORES */
 		[ C(RESULT_MISS)   ] = 0x0149, /* DTLB_STORE_MISSES.MISS_CAUSES_A_WALK */
 	},
 	[ C(OP_PREFETCH) ] = {
 		[ C(RESULT_ACCESS) ] = 0x0,
 		[ C(RESULT_MISS)   ] = 0x0,
 	},
  },
  [ C(ITLB) ] = {
 	[ C(OP_READ) ] = {
 		[ C(RESULT_ACCESS) ] = 0x1085, /* ITLB_MISSES.STLB_HIT         */
 		[ C(RESULT_MISS)   ] = 0x0185, /* ITLB_MISSES.CAUSES_A_WALK    */
 	},
 	[ C(OP_WRITE) ] = {
 		[ C(RESULT_ACCESS) ] = -1,
 		[ C(RESULT_MISS)   ] = -1,
 	},
 	[ C(OP_PREFETCH) ] = {
 		[ C(RESULT_ACCESS) ] = -1,
 		[ C(RESULT_MISS)   ] = -1,
 	},
  },
  [ C(BPU ) ] = {
 	[ C(OP_READ) ] = {
 		[ C(RESULT_ACCESS) ] = 0x00c4, /* BR_INST_RETIRED.ALL_BRANCHES */
 		[ C(RESULT_MISS)   ] = 0x00c5, /* BR_MISP_RETIRED.ALL_BRANCHES */
 	},
 	[ C(OP_WRITE) ] = {
 		[ C(RESULT_ACCESS) ] = -1,
 		[ C(RESULT_MISS)   ] = -1,
 	},
 	[ C(OP_PREFETCH) ] = {
 		[ C(RESULT_ACCESS) ] = -1,
 		[ C(RESULT_MISS)   ] = -1,
 	},
  },
  [ C(NODE) ] = {
 	[ C(OP_READ) ] = {
 		[ C(RESULT_ACCESS) ] = -1,
 		[ C(RESULT_MISS)   ] = -1,
 	},
 	[ C(OP_WRITE) ] = {
 		[ C(RESULT_ACCESS) ] = -1,
 		[ C(RESULT_MISS)   ] = -1,
 	},
 	[ C(OP_PREFETCH) ] = {
 		[ C(RESULT_ACCESS) ] = -1,
 		[ C(RESULT_MISS)   ] = -1,
 	},
  },
 };
 static __initconst const u64 westmere_hw_cache_event_ids
 				[PERF_COUNT_HW_CACHE_MAX]
 				[PERF_COUNT_HW_CACHE_OP_MAX]
 				[PERF_COUNT_HW_CACHE_RESULT_MAX] =
 {
  [ C(L1D) ] = {
 	[ C(OP_READ) ] = {
 		[ C(RESULT_ACCESS) ] = 0x010b, /* MEM_INST_RETIRED.LOADS       */
 		[ C(RESULT_MISS)   ] = 0x0151, /* L1D.REPL                     */
 	},
 	[ C(OP_WRITE) ] = {
 		[ C(RESULT_ACCESS) ] = 0x020b, /* MEM_INST_RETURED.STORES      */
 		[ C(RESULT_MISS)   ] = 0x0251, /* L1D.M_REPL                   */
 	},
 	[ C(OP_PREFETCH) ] = {
 		[ C(RESULT_ACCESS) ] = 0x014e, /* L1D_PREFETCH.REQUESTS        */
 		[ C(RESULT_MISS)   ] = 0x024e, /* L1D_PREFETCH.MISS            */
 	},
  },
  [ C(L1I ) ] = {
 	[ C(OP_READ) ] = {
 		[ C(RESULT_ACCESS) ] = 0x0380, /* L1I.READS                    */
 		[ C(RESULT_MISS)   ] = 0x0280, /* L1I.MISSES                   */
 	},
 	[ C(OP_WRITE) ] = {
 		[ C(RESULT_ACCESS) ] = -1,
 		[ C(RESULT_MISS)   ] = -1,
 	},
 	[ C(OP_PREFETCH) ] = {
 		[ C(RESULT_ACCESS) ] = 0x0,
 		[ C(RESULT_MISS)   ] = 0x0,
 	},
  },
  [ C(LL  ) ] = {
 	[ C(OP_READ) ] = {
 		/* OFFCORE_RESPONSE.ANY_DATA.LOCAL_CACHE */
 		[ C(RESULT_ACCESS) ] = 0x01b7,
 		/* OFFCORE_RESPONSE.ANY_DATA.ANY_LLC_MISS */
 		[ C(RESULT_MISS)   ] = 0x01b7,
 	},
 	/*
 	 * Use RFO, not WRITEBACK, because a write miss would typically occur
 	 * on RFO.
 	 */
 	[ C(OP_WRITE) ] = {
 		/* OFFCORE_RESPONSE.ANY_RFO.LOCAL_CACHE */
 		[ C(RESULT_ACCESS) ] = 0x01b7,
 		/* OFFCORE_RESPONSE.ANY_RFO.ANY_LLC_MISS */
 		[ C(RESULT_MISS)   ] = 0x01b7,
 	},
 	[ C(OP_PREFETCH) ] = {
 		/* OFFCORE_RESPONSE.PREFETCH.LOCAL_CACHE */
 		[ C(RESULT_ACCESS) ] = 0x01b7,
 		/* OFFCORE_RESPONSE.PREFETCH.ANY_LLC_MISS */
 		[ C(RESULT_MISS)   ] = 0x01b7,
 	},
  },
  [ C(DTLB) ] = {
 	[ C(OP_READ) ] = {
 		[ C(RESULT_ACCESS) ] = 0x010b, /* MEM_INST_RETIRED.LOADS       */
 		[ C(RESULT_MISS)   ] = 0x0108, /* DTLB_LOAD_MISSES.ANY         */
 	},
 	[ C(OP_WRITE) ] = {
 		[ C(RESULT_ACCESS) ] = 0x020b, /* MEM_INST_RETURED.STORES      */
 		[ C(RESULT_MISS)   ] = 0x010c, /* MEM_STORE_RETIRED.DTLB_MISS  */
 	},
 	[ C(OP_PREFETCH) ] = {
 		[ C(RESULT_ACCESS) ] = 0x0,
 		[ C(RESULT_MISS)   ] = 0x0,
 	},
  },
  [ C(ITLB) ] = {
 	[ C(OP_READ) ] = {
 		[ C(RESULT_ACCESS) ] = 0x01c0, /* INST_RETIRED.ANY_P           */
 		[ C(RESULT_MISS)   ] = 0x0185, /* ITLB_MISSES.ANY              */
 	},
 	[ C(OP_WRITE) ] = {
 		[ C(RESULT_ACCESS) ] = -1,
 		[ C(RESULT_MISS)   ] = -1,
 	},
 	[ C(OP_PREFETCH) ] = {
 		[ C(RESULT_ACCESS) ] = -1,
 		[ C(RESULT_MISS)   ] = -1,
 	},
  },
  [ C(BPU ) ] = {
 	[ C(OP_READ) ] = {
 		[ C(RESULT_ACCESS) ] = 0x00c4, /* BR_INST_RETIRED.ALL_BRANCHES */
 		[ C(RESULT_MISS)   ] = 0x03e8, /* BPU_CLEARS.ANY               */
 	},
 	[ C(OP_WRITE) ] = {
 		[ C(RESULT_ACCESS) ] = -1,
 		[ C(RESULT_MISS)   ] = -1,
 	},
 	[ C(OP_PREFETCH) ] = {
 		[ C(RESULT_ACCESS) ] = -1,
 		[ C(RESULT_MISS)   ] = -1,
 	},
  },
  [ C(NODE) ] = {
 	[ C(OP_READ) ] = {
 		[ C(RESULT_ACCESS) ] = 0x01b7,
 		[ C(RESULT_MISS)   ] = 0x01b7,
 	},
 	[ C(OP_WRITE) ] = {
 		[ C(RESULT_ACCESS) ] = 0x01b7,
 		[ C(RESULT_MISS)   ] = 0x01b7,
 	},
 	[ C(OP_PREFETCH) ] = {
 		[ C(RESULT_ACCESS) ] = 0x01b7,
 		[ C(RESULT_MISS)   ] = 0x01b7,
 	},
  },
 };
 /*
  * Nehalem/Westmere MSR_OFFCORE_RESPONSE bits;
  * See IA32 SDM Vol 3B 30.6.1.3
  */
 #define NHM_DMND_DATA_RD	(1 << 0)
 #define NHM_DMND_RFO		(1 << 1)
 #define NHM_DMND_IFETCH		(1 << 2)
 #define NHM_DMND_WB		(1 << 3)
 #define NHM_PF_DATA_RD		(1 << 4)
 #define NHM_PF_DATA_RFO		(1 << 5)
 #define NHM_PF_IFETCH		(1 << 6)
 #define NHM_OFFCORE_OTHER	(1 << 7)
 #define NHM_UNCORE_HIT		(1 << 8)
 #define NHM_OTHER_CORE_HIT_SNP	(1 << 9)
 #define NHM_OTHER_CORE_HITM	(1 << 10)
         			/* reserved */
 #define NHM_REMOTE_CACHE_FWD	(1 << 12)
 #define NHM_REMOTE_DRAM		(1 << 13)
 #define NHM_LOCAL_DRAM		(1 << 14)
 #define NHM_NON_DRAM		(1 << 15)
 #define NHM_ALL_DRAM		(NHM_REMOTE_DRAM|NHM_LOCAL_DRAM)
 #define NHM_DMND_READ		(NHM_DMND_DATA_RD)
 #define NHM_DMND_WRITE		(NHM_DMND_RFO|NHM_DMND_WB)
 #define NHM_DMND_PREFETCH	(NHM_PF_DATA_RD|NHM_PF_DATA_RFO)
 #define NHM_L3_HIT	(NHM_UNCORE_HIT|NHM_OTHER_CORE_HIT_SNP|NHM_OTHER_CORE_HITM)
 #define NHM_L3_MISS	(NHM_NON_DRAM|NHM_ALL_DRAM|NHM_REMOTE_CACHE_FWD)
 #define NHM_L3_ACCESS	(NHM_L3_HIT|NHM_L3_MISS)
 static __initconst const u64 nehalem_hw_cache_extra_regs
 				[PERF_COUNT_HW_CACHE_MAX]
 				[PERF_COUNT_HW_CACHE_OP_MAX]
 				[PERF_COUNT_HW_CACHE_RESULT_MAX] =
 {
  [ C(LL  ) ] = {
 	[ C(OP_READ) ] = {
 		[ C(RESULT_ACCESS) ] = NHM_DMND_READ|NHM_L3_ACCESS,
 		[ C(RESULT_MISS)   ] = NHM_DMND_READ|NHM_L3_MISS,
 	},
 	[ C(OP_WRITE) ] = {
 		[ C(RESULT_ACCESS) ] = NHM_DMND_WRITE|NHM_L3_ACCESS,
 		[ C(RESULT_MISS)   ] = NHM_DMND_WRITE|NHM_L3_MISS,
 	},
 	[ C(OP_PREFETCH) ] = {
 		[ C(RESULT_ACCESS) ] = NHM_DMND_PREFETCH|NHM_L3_ACCESS,
 		[ C(RESULT_MISS)   ] = NHM_DMND_PREFETCH|NHM_L3_MISS,
 	},
  },
  [ C(NODE) ] = {
 	[ C(OP_READ) ] = {
 		[ C(RESULT_ACCESS) ] = NHM_DMND_READ|NHM_ALL_DRAM,
 		[ C(RESULT_MISS)   ] = NHM_DMND_READ|NHM_REMOTE_DRAM,
 	},
 	[ C(OP_WRITE) ] = {
 		[ C(RESULT_ACCESS) ] = NHM_DMND_WRITE|NHM_ALL_DRAM,
 		[ C(RESULT_MISS)   ] = NHM_DMND_WRITE|NHM_REMOTE_DRAM,
 	},
 	[ C(OP_PREFETCH) ] = {
 		[ C(RESULT_ACCESS) ] = NHM_DMND_PREFETCH|NHM_ALL_DRAM,
 		[ C(RESULT_MISS)   ] = NHM_DMND_PREFETCH|NHM_REMOTE_DRAM,
 	},
  },
 };
 static __initconst const u64 nehalem_hw_cache_event_ids
 				[PERF_COUNT_HW_CACHE_MAX]
 				[PERF_COUNT_HW_CACHE_OP_MAX]
 				[PERF_COUNT_HW_CACHE_RESULT_MAX] =
 {
  [ C(L1D) ] = {
 	[ C(OP_READ) ] = {
 		[ C(RESULT_ACCESS) ] = 0x010b, /* MEM_INST_RETIRED.LOADS       */
 		[ C(RESULT_MISS)   ] = 0x0151, /* L1D.REPL                     */
 	},
 	[ C(OP_WRITE) ] = {
 		[ C(RESULT_ACCESS) ] = 0x020b, /* MEM_INST_RETURED.STORES      */
 		[ C(RESULT_MISS)   ] = 0x0251, /* L1D.M_REPL                   */
 	},
 	[ C(OP_PREFETCH) ] = {
 		[ C(RESULT_ACCESS) ] = 0x014e, /* L1D_PREFETCH.REQUESTS        */
 		[ C(RESULT_MISS)   ] = 0x024e, /* L1D_PREFETCH.MISS            */
 	},
  },
  [ C(L1I ) ] = {
 	[ C(OP_READ) ] = {
 		[ C(RESULT_ACCESS) ] = 0x0380, /* L1I.READS                    */
 		[ C(RESULT_MISS)   ] = 0x0280, /* L1I.MISSES                   */
 	},
 	[ C(OP_WRITE) ] = {
 		[ C(RESULT_ACCESS) ] = -1,
 		[ C(RESULT_MISS)   ] = -1,
 	},
 	[ C(OP_PREFETCH) ] = {
 		[ C(RESULT_ACCESS) ] = 0x0,
 		[ C(RESULT_MISS)   ] = 0x0,
 	},
  },
  [ C(LL  ) ] = {
 	[ C(OP_READ) ] = {
 		/* OFFCORE_RESPONSE.ANY_DATA.LOCAL_CACHE */
 		[ C(RESULT_ACCESS) ] = 0x01b7,
 		/* OFFCORE_RESPONSE.ANY_DATA.ANY_LLC_MISS */
 		[ C(RESULT_MISS)   ] = 0x01b7,
 	},
 	/*
 	 * Use RFO, not WRITEBACK, because a write miss would typically occur
 	 * on RFO.
 	 */
 	[ C(OP_WRITE) ] = {
 		/* OFFCORE_RESPONSE.ANY_RFO.LOCAL_CACHE */
 		[ C(RESULT_ACCESS) ] = 0x01b7,
 		/* OFFCORE_RESPONSE.ANY_RFO.ANY_LLC_MISS */
 		[ C(RESULT_MISS)   ] = 0x01b7,
 	},
 	[ C(OP_PREFETCH) ] = {
 		/* OFFCORE_RESPONSE.PREFETCH.LOCAL_CACHE */
 		[ C(RESULT_ACCESS) ] = 0x01b7,
 		/* OFFCORE_RESPONSE.PREFETCH.ANY_LLC_MISS */
 		[ C(RESULT_MISS)   ] = 0x01b7,
 	},
  },
  [ C(DTLB) ] = {
 	[ C(OP_READ) ] = {
 		[ C(RESULT_ACCESS) ] = 0x0f40, /* L1D_CACHE_LD.MESI   (alias)  */
 		[ C(RESULT_MISS)   ] = 0x0108, /* DTLB_LOAD_MISSES.ANY         */
 	},
 	[ C(OP_WRITE) ] = {
 		[ C(RESULT_ACCESS) ] = 0x0f41, /* L1D_CACHE_ST.MESI   (alias)  */
 		[ C(RESULT_MISS)   ] = 0x010c, /* MEM_STORE_RETIRED.DTLB_MISS  */
 	},
 	[ C(OP_PREFETCH) ] = {
 		[ C(RESULT_ACCESS) ] = 0x0,
 		[ C(RESULT_MISS)   ] = 0x0,
 	},
  },
  [ C(ITLB) ] = {
 	[ C(OP_READ) ] = {
 		[ C(RESULT_ACCESS) ] = 0x01c0, /* INST_RETIRED.ANY_P           */
 		[ C(RESULT_MISS)   ] = 0x20c8, /* ITLB_MISS_RETIRED            */
 	},
 	[ C(OP_WRITE) ] = {
 		[ C(RESULT_ACCESS) ] = -1,
 		[ C(RESULT_MISS)   ] = -1,
 	},
 	[ C(OP_PREFETCH) ] = {
 		[ C(RESULT_ACCESS) ] = -1,
 		[ C(RESULT_MISS)   ] = -1,
 	},
  },
  [ C(BPU ) ] = {
 	[ C(OP_READ) ] = {
 		[ C(RESULT_ACCESS) ] = 0x00c4, /* BR_INST_RETIRED.ALL_BRANCHES */
 		[ C(RESULT_MISS)   ] = 0x03e8, /* BPU_CLEARS.ANY               */
 	},
 	[ C(OP_WRITE) ] = {
 		[ C(RESULT_ACCESS) ] = -1,
 		[ C(RESULT_MISS)   ] = -1,
 	},
 	[ C(OP_PREFETCH) ] = {
 		[ C(RESULT_ACCESS) ] = -1,
 		[ C(RESULT_MISS)   ] = -1,
 	},
  },
  [ C(NODE) ] = {
 	[ C(OP_READ) ] = {
 		[ C(RESULT_ACCESS) ] = 0x01b7,
 		[ C(RESULT_MISS)   ] = 0x01b7,
 	},
 	[ C(OP_WRITE) ] = {
 		[ C(RESULT_ACCESS) ] = 0x01b7,
 		[ C(RESULT_MISS)   ] = 0x01b7,
 	},
 	[ C(OP_PREFETCH) ] = {
 		[ C(RESULT_ACCESS) ] = 0x01b7,
 		[ C(RESULT_MISS)   ] = 0x01b7,
 	},
  },
 };
 static __initconst const u64 core2_hw_cache_event_ids
 				[PERF_COUNT_HW_CACHE_MAX]
 				[PERF_COUNT_HW_CACHE_OP_MAX]
 				[PERF_COUNT_HW_CACHE_RESULT_MAX] =
 {
  [ C(L1D) ] = {
 	[ C(OP_READ) ] = {
 		[ C(RESULT_ACCESS) ] = 0x0f40, /* L1D_CACHE_LD.MESI          */
 		[ C(RESULT_MISS)   ] = 0x0140, /* L1D_CACHE_LD.I_STATE       */
 	},
 	[ C(OP_WRITE) ] = {
 		[ C(RESULT_ACCESS) ] = 0x0f41, /* L1D_CACHE_ST.MESI          */
 		[ C(RESULT_MISS)   ] = 0x0141, /* L1D_CACHE_ST.I_STATE       */
 	},
 	[ C(OP_PREFETCH) ] = {
 		[ C(RESULT_ACCESS) ] = 0x104e, /* L1D_PREFETCH.REQUESTS      */
 		[ C(RESULT_MISS)   ] = 0,
 	},
  },
  [ C(L1I ) ] = {
 	[ C(OP_READ) ] = {
 		[ C(RESULT_ACCESS) ] = 0x0080, /* L1I.READS                  */
 		[ C(RESULT_MISS)   ] = 0x0081, /* L1I.MISSES                 */
 	},
 	[ C(OP_WRITE) ] = {
 		[ C(RESULT_ACCESS) ] = -1,
 		[ C(RESULT_MISS)   ] = -1,
 	},
 	[ C(OP_PREFETCH) ] = {
 		[ C(RESULT_ACCESS) ] = 0,
 		[ C(RESULT_MISS)   ] = 0,
 	},
  },
  [ C(LL  ) ] = {
 	[ C(OP_READ) ] = {
 		[ C(RESULT_ACCESS) ] = 0x4f29, /* L2_LD.MESI                 */
 		[ C(RESULT_MISS)   ] = 0x4129, /* L2_LD.ISTATE               */
 	},
 	[ C(OP_WRITE) ] = {
 		[ C(RESULT_ACCESS) ] = 0x4f2A, /* L2_ST.MESI                 */
 		[ C(RESULT_MISS)   ] = 0x412A, /* L2_ST.ISTATE               */
 	},
 	[ C(OP_PREFETCH) ] = {
 		[ C(RESULT_ACCESS) ] = 0,
 		[ C(RESULT_MISS)   ] = 0,
 	},
  },
  [ C(DTLB) ] = {
 	[ C(OP_READ) ] = {
 		[ C(RESULT_ACCESS) ] = 0x0f40, /* L1D_CACHE_LD.MESI  (alias) */
 		[ C(RESULT_MISS)   ] = 0x0208, /* DTLB_MISSES.MISS_LD        */
 	},
 	[ C(OP_WRITE) ] = {
 		[ C(RESULT_ACCESS) ] = 0x0f41, /* L1D_CACHE_ST.MESI  (alias) */
 		[ C(RESULT_MISS)   ] = 0x0808, /* DTLB_MISSES.MISS_ST        */
 	},
 	[ C(OP_PREFETCH) ] = {
 		[ C(RESULT_ACCESS) ] = 0,
 		[ C(RESULT_MISS)   ] = 0,
 	},
  },
  [ C(ITLB) ] = {
 	[ C(OP_READ) ] = {
 		[ C(RESULT_ACCESS) ] = 0x00c0, /* INST_RETIRED.ANY_P         */
 		[ C(RESULT_MISS)   ] = 0x1282, /* ITLBMISSES                 */
 	},
 	[ C(OP_WRITE) ] = {
 		[ C(RESULT_ACCESS) ] = -1,
 		[ C(RESULT_MISS)   ] = -1,
 	},
 	[ C(OP_PREFETCH) ] = {
 		[ C(RESULT_ACCESS) ] = -1,
 		[ C(RESULT_MISS)   ] = -1,
 	},
  },
  [ C(BPU ) ] = {
 	[ C(OP_READ) ] = {
 		[ C(RESULT_ACCESS) ] = 0x00c4, /* BR_INST_RETIRED.ANY        */
 		[ C(RESULT_MISS)   ] = 0x00c5, /* BP_INST_RETIRED.MISPRED    */
 	},
 	[ C(OP_WRITE) ] = {
 		[ C(RESULT_ACCESS) ] = -1,
 		[ C(RESULT_MISS)   ] = -1,
 	},
 	[ C(OP_PREFETCH) ] = {
 		[ C(RESULT_ACCESS) ] = -1,
 		[ C(RESULT_MISS)   ] = -1,
 	},
  },
 };
 static __initconst const u64 atom_hw_cache_event_ids
 				[PERF_COUNT_HW_CACHE_MAX]
 				[PERF_COUNT_HW_CACHE_OP_MAX]
 				[PERF_COUNT_HW_CACHE_RESULT_MAX] =
 {
  [ C(L1D) ] = {
 	[ C(OP_READ) ] = {
 		[ C(RESULT_ACCESS) ] = 0x2140, /* L1D_CACHE.LD               */
 		[ C(RESULT_MISS)   ] = 0,
 	},
 	[ C(OP_WRITE) ] = {
 		[ C(RESULT_ACCESS) ] = 0x2240, /* L1D_CACHE.ST               */
 		[ C(RESULT_MISS)   ] = 0,
 	},
 	[ C(OP_PREFETCH) ] = {
 		[ C(RESULT_ACCESS) ] = 0x0,
 		[ C(RESULT_MISS)   ] = 0,
 	},
  },
  [ C(L1I ) ] = {
 	[ C(OP_READ) ] = {
 		[ C(RESULT_ACCESS) ] = 0x0380, /* L1I.READS                  */
 		[ C(RESULT_MISS)   ] = 0x0280, /* L1I.MISSES                 */
 	},
 	[ C(OP_WRITE) ] = {
 		[ C(RESULT_ACCESS) ] = -1,
 		[ C(RESULT_MISS)   ] = -1,
 	},
 	[ C(OP_PREFETCH) ] = {
 		[ C(RESULT_ACCESS) ] = 0,
 		[ C(RESULT_MISS)   ] = 0,
 	},
  },
  [ C(LL  ) ] = {
 	[ C(OP_READ) ] = {
 		[ C(RESULT_ACCESS) ] = 0x4f29, /* L2_LD.MESI                 */
 		[ C(RESULT_MISS)   ] = 0x4129, /* L2_LD.ISTATE               */
 	},
 	[ C(OP_WRITE) ] = {
 		[ C(RESULT_ACCESS) ] = 0x4f2A, /* L2_ST.MESI                 */
 		[ C(RESULT_MISS)   ] = 0x412A, /* L2_ST.ISTATE               */
 	},
 	[ C(OP_PREFETCH) ] = {
 		[ C(RESULT_ACCESS) ] = 0,
 		[ C(RESULT_MISS)   ] = 0,
 	},
  },
  [ C(DTLB) ] = {
 	[ C(OP_READ) ] = {
 		[ C(RESULT_ACCESS) ] = 0x2140, /* L1D_CACHE_LD.MESI  (alias) */
 		[ C(RESULT_MISS)   ] = 0x0508, /* DTLB_MISSES.MISS_LD        */
 	},
 	[ C(OP_WRITE) ] = {
 		[ C(RESULT_ACCESS) ] = 0x2240, /* L1D_CACHE_ST.MESI  (alias) */
 		[ C(RESULT_MISS)   ] = 0x0608, /* DTLB_MISSES.MISS_ST        */
 	},
 	[ C(OP_PREFETCH) ] = {
 		[ C(RESULT_ACCESS) ] = 0,
 		[ C(RESULT_MISS)   ] = 0,
 	},
  },
  [ C(ITLB) ] = {
 	[ C(OP_READ) ] = {
 		[ C(RESULT_ACCESS) ] = 0x00c0, /* INST_RETIRED.ANY_P         */
 		[ C(RESULT_MISS)   ] = 0x0282, /* ITLB.MISSES                */
 	},
 	[ C(OP_WRITE) ] = {
 		[ C(RESULT_ACCESS) ] = -1,
 		[ C(RESULT_MISS)   ] = -1,
 	},
 	[ C(OP_PREFETCH) ] = {
 		[ C(RESULT_ACCESS) ] = -1,
 		[ C(RESULT_MISS)   ] = -1,
 	},
  },
  [ C(BPU ) ] = {
 	[ C(OP_READ) ] = {
 		[ C(RESULT_ACCESS) ] = 0x00c4, /* BR_INST_RETIRED.ANY        */
 		[ C(RESULT_MISS)   ] = 0x00c5, /* BP_INST_RETIRED.MISPRED    */
 	},
 	[ C(OP_WRITE) ] = {
 		[ C(RESULT_ACCESS) ] = -1,
 		[ C(RESULT_MISS)   ] = -1,
 	},
 	[ C(OP_PREFETCH) ] = {
 		[ C(RESULT_ACCESS) ] = -1,
 		[ C(RESULT_MISS)   ] = -1,
 	},
  },
 };
 static void intel_pmu_disable_all(void)
 {
 	struct cpu_hw_events *cpuc = &__get_cpu_var(cpu_hw_events);
 	wrmsrl(MSR_CORE_PERF_GLOBAL_CTRL, 0);
 	if (test_bit(X86_PMC_IDX_FIXED_BTS, cpuc->active_mask))
 		intel_pmu_disable_bts();
 	intel_pmu_pebs_disable_all();
 	intel_pmu_lbr_disable_all();
 }
 static void intel_pmu_enable_all(int added)
 {
 	struct cpu_hw_events *cpuc = &__get_cpu_var(cpu_hw_events);
 	intel_pmu_pebs_enable_all();
 	intel_pmu_lbr_enable_all();
 	wrmsrl(MSR_CORE_PERF_GLOBAL_CTRL, x86_pmu.intel_ctrl);
 	if (test_bit(X86_PMC_IDX_FIXED_BTS, cpuc->active_mask)) {
 		struct perf_event *event =
 			cpuc->events[X86_PMC_IDX_FIXED_BTS];
 		if (WARN_ON_ONCE(!event))
 			return;
 		intel_pmu_enable_bts(event->hw.config);
 	}
 }
 /*
  * Workaround for:
  *   Intel Errata AAK100 (model 26)
  *   Intel Errata AAP53  (model 30)
  *   Intel Errata BD53   (model 44)
  *
  * The official story:
  *   These chips need to be 'reset' when adding counters by programming the
  *   magic three (non-counting) events 0x4300B5, 0x4300D2, and 0x4300B1 either
  *   in sequence on the same PMC or on different PMCs.
  *
  * In practise it appears some of these events do in fact count, and
  * we need to programm all 4 events.
  */
 static void intel_pmu_nhm_workaround(void)
 {
 	struct cpu_hw_events *cpuc = &__get_cpu_var(cpu_hw_events);
 	static const unsigned long nhm_magic[4] = {
 		0x4300B5,
 		0x4300D2,
 		0x4300B1,
 		0x4300B1
 	};
 	struct perf_event *event;
 	int i;
 	/*
 	 * The Errata requires below steps:
 	 * 1) Clear MSR_IA32_PEBS_ENABLE and MSR_CORE_PERF_GLOBAL_CTRL;
 	 * 2) Configure 4 PERFEVTSELx with the magic events and clear
 	 *    the corresponding PMCx;
 	 * 3) set bit0~bit3 of MSR_CORE_PERF_GLOBAL_CTRL;
 	 * 4) Clear MSR_CORE_PERF_GLOBAL_CTRL;
 	 * 5) Clear 4 pairs of ERFEVTSELx and PMCx;
 	 */
 	/*
 	 * The real steps we choose are a little different from above.
 	 * A) To reduce MSR operations, we don't run step 1) as they
 	 *    are already cleared before this function is called;
 	 * B) Call x86_perf_event_update to save PMCx before configuring
 	 *    PERFEVTSELx with magic number;
 	 * C) With step 5), we do clear only when the PERFEVTSELx is
 	 *    not used currently.
 	 * D) Call x86_perf_event_set_period to restore PMCx;
 	 */
 	/* We always operate 4 pairs of PERF Counters */
 	for (i = 0; i < 4; i++) {
 		event = cpuc->events[i];
 		if (event)
 			x86_perf_event_update(event);
 	}
 	for (i = 0; i < 4; i++) {
 		wrmsrl(MSR_ARCH_PERFMON_EVENTSEL0 + i, nhm_magic[i]);
 		wrmsrl(MSR_ARCH_PERFMON_PERFCTR0 + i, 0x0);
 	}
 	wrmsrl(MSR_CORE_PERF_GLOBAL_CTRL, 0xf);
 	wrmsrl(MSR_CORE_PERF_GLOBAL_CTRL, 0x0);
 	for (i = 0; i < 4; i++) {
 		event = cpuc->events[i];
 		if (event) {
 			x86_perf_event_set_period(event);
 			__x86_pmu_enable_event(&event->hw,
 					ARCH_PERFMON_EVENTSEL_ENABLE);
 		} else
 			wrmsrl(MSR_ARCH_PERFMON_EVENTSEL0 + i, 0x0);
 	}
 }
 static void intel_pmu_nhm_enable_all(int added)
 {
 	if (added)
 		intel_pmu_nhm_workaround();
 	intel_pmu_enable_all(added);
 }
 static inline u64 intel_pmu_get_status(void)
 {
 	u64 status;
 	rdmsrl(MSR_CORE_PERF_GLOBAL_STATUS, status);
 	return status;
 }
 static inline void intel_pmu_ack_status(u64 ack)
 {
 	wrmsrl(MSR_CORE_PERF_GLOBAL_OVF_CTRL, ack);
 }
 static void intel_pmu_disable_fixed(struct hw_perf_event *hwc)
 {
 	int idx = hwc->idx - X86_PMC_IDX_FIXED;
 	u64 ctrl_val, mask;
 	mask = 0xfULL << (idx * 4);
 	rdmsrl(hwc->config_base, ctrl_val);
 	ctrl_val &= ~mask;
 	wrmsrl(hwc->config_base, ctrl_val);
 }
 static void intel_pmu_disable_event(struct perf_event *event)
 {
 	struct hw_perf_event *hwc = &event->hw;
 	if (unlikely(hwc->idx == X86_PMC_IDX_FIXED_BTS)) {
 		intel_pmu_disable_bts();
 		intel_pmu_drain_bts_buffer();
 		return;
 	}
 	if (unlikely(hwc->config_base == MSR_ARCH_PERFMON_FIXED_CTR_CTRL)) {
 		intel_pmu_disable_fixed(hwc);
 		return;
 	}
 	x86_pmu_disable_event(event);
 	if (unlikely(event->attr.precise_ip))
 		intel_pmu_pebs_disable(event);
 }
 static void intel_pmu_enable_fixed(struct hw_perf_event *hwc)
 {
 	int idx = hwc->idx - X86_PMC_IDX_FIXED;
 	u64 ctrl_val, bits, mask;
 	/*
 	 * Enable IRQ generation (0x8),
 	 * and enable ring-3 counting (0x2) and ring-0 counting (0x1)
 	 * if requested:
 	 */
 	bits = 0x8ULL;
 	if (hwc->config & ARCH_PERFMON_EVENTSEL_USR)
 		bits |= 0x2;
 	if (hwc->config & ARCH_PERFMON_EVENTSEL_OS)
 		bits |= 0x1;
 	/*
 	 * ANY bit is supported in v3 and up
 	 */
 	if (x86_pmu.version > 2 && hwc->config & ARCH_PERFMON_EVENTSEL_ANY)
 		bits |= 0x4;
 	bits <<= (idx * 4);
 	mask = 0xfULL << (idx * 4);
 	rdmsrl(hwc->config_base, ctrl_val);
 	ctrl_val &= ~mask;
 	ctrl_val |= bits;
 	wrmsrl(hwc->config_base, ctrl_val);
 }
 static void intel_pmu_enable_event(struct perf_event *event)
 {
 	struct hw_perf_event *hwc = &event->hw;
 	if (unlikely(hwc->idx == X86_PMC_IDX_FIXED_BTS)) {
 		if (!__this_cpu_read(cpu_hw_events.enabled))
 			return;
 		intel_pmu_enable_bts(hwc->config);
 		return;
 	}
 	if (unlikely(hwc->config_base == MSR_ARCH_PERFMON_FIXED_CTR_CTRL)) {
 		intel_pmu_enable_fixed(hwc);
 		return;
 	}
 	if (unlikely(event->attr.precise_ip))
 		intel_pmu_pebs_enable(event);
 	__x86_pmu_enable_event(hwc, ARCH_PERFMON_EVENTSEL_ENABLE);
 }
 /*
  * Save and restart an expired event. Called by NMI contexts,
  * so it has to be careful about preempting normal event ops:
  */
 static int intel_pmu_save_and_restart(struct perf_event *event)
 {
 	x86_perf_event_update(event);
 	return x86_perf_event_set_period(event);
 }
 static void intel_pmu_reset(void)
 {
 	struct debug_store *ds = __this_cpu_read(cpu_hw_events.ds);
 	unsigned long flags;
 	int idx;
 	if (!x86_pmu.num_counters)
 		return;
 	local_irq_save(flags);
 	printk("clearing PMU state on CPU#%d\n", smp_processor_id());
 	for (idx = 0; idx < x86_pmu.num_counters; idx++) {
 		checking_wrmsrl(x86_pmu_config_addr(idx), 0ull);
 		checking_wrmsrl(x86_pmu_event_addr(idx),  0ull);
 	}
 	for (idx = 0; idx < x86_pmu.num_counters_fixed; idx++)
 		checking_wrmsrl(MSR_ARCH_PERFMON_FIXED_CTR0 + idx, 0ull);
 	if (ds)
 		ds->bts_index = ds->bts_buffer_base;
 	local_irq_restore(flags);
 }
 /*
  * This handler is triggered by the local APIC, so the APIC IRQ handling
  * rules apply:
  */
 static int intel_pmu_handle_irq(struct pt_regs *regs)
 {
 	struct perf_sample_data data;
 	struct cpu_hw_events *cpuc;
 	int bit, loops;
 	u64 status;
 	int handled;
 	perf_sample_data_init(&data, 0);
 	cpuc = &__get_cpu_var(cpu_hw_events);
 	/*
 	 * Some chipsets need to unmask the LVTPC in a particular spot
 	 * inside the nmi handler.  As a result, the unmasking was pushed
 	 * into all the nmi handlers.
 	 *
 	 * This handler doesn't seem to have any issues with the unmasking
 	 * so it was left at the top.
 	 */
 	apic_write(APIC_LVTPC, APIC_DM_NMI);
 	intel_pmu_disable_all();
 	handled = intel_pmu_drain_bts_buffer();
 	status = intel_pmu_get_status();
 	if (!status) {
 		intel_pmu_enable_all(0);
 		return handled;
 	}
 	loops = 0;
 again:
 	intel_pmu_ack_status(status);
 	if (++loops > 100) {
 		WARN_ONCE(1, "perfevents: irq loop stuck!\n");
 		perf_event_print_debug();
 		intel_pmu_reset();
 		goto done;
 	}
 	inc_irq_stat(apic_perf_irqs);
 	intel_pmu_lbr_read();
 	/*
 	 * PEBS overflow sets bit 62 in the global status register
 	 */
 	if (__test_and_clear_bit(62, (unsigned long *)&status)) {
 		handled++;
 		x86_pmu.drain_pebs(regs);
 	}
 	for_each_set_bit(bit, (unsigned long *)&status, X86_PMC_IDX_MAX) {
 		struct perf_event *event = cpuc->events[bit];
 		handled++;
 		if (!test_bit(bit, cpuc->active_mask))
 			continue;
 		if (!intel_pmu_save_and_restart(event))
 			continue;
 		data.period = event->hw.last_period;
 		if (perf_event_overflow(event, &data, regs))
 			x86_pmu_stop(event, 0);
 	}
 	/*
 	 * Repeat if there is more work to be done:
 	 */
 	status = intel_pmu_get_status();
 	if (status)
 		goto again;
 done:
 	intel_pmu_enable_all(0);
 	return handled;
 }
 static struct event_constraint *
 intel_bts_constraints(struct perf_event *event)
 {
 	struct hw_perf_event *hwc = &event->hw;
 	unsigned int hw_event, bts_event;
 	if (event->attr.freq)
 		return NULL;
 	hw_event = hwc->config & INTEL_ARCH_EVENT_MASK;
 	bts_event = x86_pmu.event_map(PERF_COUNT_HW_BRANCH_INSTRUCTIONS);
 	if (unlikely(hw_event == bts_event && hwc->sample_period == 1))
 		return &bts_constraint;
 	return NULL;
 }
 static bool intel_try_alt_er(struct perf_event *event, int orig_idx)
 {
 	if (!(x86_pmu.er_flags & ERF_HAS_RSP_1))
 		return false;
 	if (event->hw.extra_reg.idx == EXTRA_REG_RSP_0) {
 		event->hw.config &= ~INTEL_ARCH_EVENT_MASK;
 		event->hw.config |= 0x01bb;
 		event->hw.extra_reg.idx = EXTRA_REG_RSP_1;
 		event->hw.extra_reg.reg = MSR_OFFCORE_RSP_1;
 	} else if (event->hw.extra_reg.idx == EXTRA_REG_RSP_1) {
 		event->hw.config &= ~INTEL_ARCH_EVENT_MASK;
 		event->hw.config |= 0x01b7;
 		event->hw.extra_reg.idx = EXTRA_REG_RSP_0;
 		event->hw.extra_reg.reg = MSR_OFFCORE_RSP_0;
 	}
 	if (event->hw.extra_reg.idx == orig_idx)
 		return false;
 	return true;
 }
 /*
  * manage allocation of shared extra msr for certain events
  *
  * sharing can be:
  * per-cpu: to be shared between the various events on a single PMU
  * per-core: per-cpu + shared by HT threads
  */
 static struct event_constraint *
 __intel_shared_reg_get_constraints(struct cpu_hw_events *cpuc,
 				   struct perf_event *event)
 {
 	struct event_constraint *c = &emptyconstraint;
 	struct hw_perf_event_extra *reg = &event->hw.extra_reg;
 	struct er_account *era;
 	unsigned long flags;
 	int orig_idx = reg->idx;
 	/* already allocated shared msr */
 	if (reg->alloc)
 		return &unconstrained;
 again:
 	era = &cpuc->shared_regs->regs[reg->idx];
 	/*
 	 * we use spin_lock_irqsave() to avoid lockdep issues when
 	 * passing a fake cpuc
 	 */
 	raw_spin_lock_irqsave(&era->lock, flags);
 	if (!atomic_read(&era->ref) || era->config == reg->config) {
 		/* lock in msr value */
 		era->config = reg->config;
 		era->reg = reg->reg;
 		/* one more user */
 		atomic_inc(&era->ref);
 		/* no need to reallocate during incremental event scheduling */
 		reg->alloc = 1;
 		/*
 		 * All events using extra_reg are unconstrained.
 		 * Avoids calling x86_get_event_constraints()
 		 *
 		 * Must revisit if extra_reg controlling events
 		 * ever have constraints. Worst case we go through
 		 * the regular event constraint table.
 		 */
 		c = &unconstrained;
 	} else if (intel_try_alt_er(event, orig_idx)) {
 		raw_spin_unlock(&era->lock);
 		goto again;
 	}
 	raw_spin_unlock_irqrestore(&era->lock, flags);
 	return c;
 }
 static void
 __intel_shared_reg_put_constraints(struct cpu_hw_events *cpuc,
 				   struct hw_perf_event_extra *reg)
 {
 	struct er_account *era;
 	/*
 	 * only put constraint if extra reg was actually
 	 * allocated. Also takes care of event which do
 	 * not use an extra shared reg
 	 */
 	if (!reg->alloc)
 		return;
 	era = &cpuc->shared_regs->regs[reg->idx];
 	/* one fewer user */
 	atomic_dec(&era->ref);
 	/* allocate again next time */
 	reg->alloc = 0;
 }
 static struct event_constraint *
 intel_shared_regs_constraints(struct cpu_hw_events *cpuc,
 			      struct perf_event *event)
 {
 	struct event_constraint *c = NULL;
 	if (event->hw.extra_reg.idx != EXTRA_REG_NONE)
 		c = __intel_shared_reg_get_constraints(cpuc, event);
 	return c;
 }
 static struct event_constraint *
 intel_get_event_constraints(struct cpu_hw_events *cpuc, struct perf_event *event)
 {
 	struct event_constraint *c;
 	c = intel_bts_constraints(event);
 	if (c)
 		return c;
 	c = intel_pebs_constraints(event);
 	if (c)
 		return c;
 	c = intel_shared_regs_constraints(cpuc, event);
 	if (c)
 		return c;
 	return x86_get_event_constraints(cpuc, event);
 }
 static void
 intel_put_shared_regs_event_constraints(struct cpu_hw_events *cpuc,
 					struct perf_event *event)
 {
 	struct hw_perf_event_extra *reg;
 	reg = &event->hw.extra_reg;
 	if (reg->idx != EXTRA_REG_NONE)
 		__intel_shared_reg_put_constraints(cpuc, reg);
 }
 static void intel_put_event_constraints(struct cpu_hw_events *cpuc,
 					struct perf_event *event)
 {
 	intel_put_shared_regs_event_constraints(cpuc, event);
 }
 static int intel_pmu_hw_config(struct perf_event *event)
 {
 	int ret = x86_pmu_hw_config(event);
 	if (ret)
 		return ret;
 	if (event->attr.precise_ip &&
 	    (event->hw.config & X86_RAW_EVENT_MASK) == 0x003c) {
 		/*
 		 * Use an alternative encoding for CPU_CLK_UNHALTED.THREAD_P
 		 * (0x003c) so that we can use it with PEBS.
 		 *
 		 * The regular CPU_CLK_UNHALTED.THREAD_P event (0x003c) isn't
 		 * PEBS capable. However we can use INST_RETIRED.ANY_P
 		 * (0x00c0), which is a PEBS capable event, to get the same
 		 * count.
 		 *
 		 * INST_RETIRED.ANY_P counts the number of cycles that retires
 		 * CNTMASK instructions. By setting CNTMASK to a value (16)
 		 * larger than the maximum number of instructions that can be
 		 * retired per cycle (4) and then inverting the condition, we
 		 * count all cycles that retire 16 or less instructions, which
 		 * is every cycle.
 		 *
 		 * Thereby we gain a PEBS capable cycle counter.
 		 */
 		u64 alt_config = 0x108000c0; /* INST_RETIRED.TOTAL_CYCLES */
 		alt_config |= (event->hw.config & ~X86_RAW_EVENT_MASK);
 		event->hw.config = alt_config;
 	}
 	if (event->attr.type != PERF_TYPE_RAW)
 		return 0;
 	if (!(event->attr.config & ARCH_PERFMON_EVENTSEL_ANY))
 		return 0;
 	if (x86_pmu.version < 3)
 		return -EINVAL;
 	if (perf_paranoid_cpu() && !capable(CAP_SYS_ADMIN))
 		return -EACCES;
 	event->hw.config |= ARCH_PERFMON_EVENTSEL_ANY;
 	return 0;
 }
 static __initconst const struct x86_pmu core_pmu = {
 	.name			= "core",
 	.handle_irq		= x86_pmu_handle_irq,
 	.disable_all		= x86_pmu_disable_all,
 	.enable_all		= x86_pmu_enable_all,
 	.enable			= x86_pmu_enable_event,
 	.disable		= x86_pmu_disable_event,
 	.hw_config		= x86_pmu_hw_config,
 	.schedule_events	= x86_schedule_events,
 	.eventsel		= MSR_ARCH_PERFMON_EVENTSEL0,
 	.perfctr		= MSR_ARCH_PERFMON_PERFCTR0,
 	.event_map		= intel_pmu_event_map,
 	.max_events		= ARRAY_SIZE(intel_perfmon_event_map),
 	.apic			= 1,
 	/*
 	 * Intel PMCs cannot be accessed sanely above 32 bit width,
 	 * so we install an artificial 1<<31 period regardless of
 	 * the generic event period:
 	 */
 	.max_period		= (1ULL << 31) - 1,
 	.get_event_constraints	= intel_get_event_constraints,
 	.put_event_constraints	= intel_put_event_constraints,
 	.event_constraints	= intel_core_event_constraints,
 };
 static struct intel_shared_regs *allocate_shared_regs(int cpu)
 {
 	struct intel_shared_regs *regs;
 	int i;
 	regs = kzalloc_node(sizeof(struct intel_shared_regs),
 			    GFP_KERNEL, cpu_to_node(cpu));
 	if (regs) {
 		/*
 		 * initialize the locks to keep lockdep happy
 		 */
 		for (i = 0; i < EXTRA_REG_MAX; i++)
 			raw_spin_lock_init(&regs->regs[i].lock);
 		regs->core_id = -1;
 	}
 	return regs;
 }
 static int intel_pmu_cpu_prepare(int cpu)
 {
 	struct cpu_hw_events *cpuc = &per_cpu(cpu_hw_events, cpu);
 	if (!x86_pmu.extra_regs)
 		return NOTIFY_OK;
 	cpuc->shared_regs = allocate_shared_regs(cpu);
 	if (!cpuc->shared_regs)
 		return NOTIFY_BAD;
 	return NOTIFY_OK;
 }
 static void intel_pmu_cpu_starting(int cpu)
 {
 	struct cpu_hw_events *cpuc = &per_cpu(cpu_hw_events, cpu);
 	int core_id = topology_core_id(cpu);
 	int i;
 	init_debug_store_on_cpu(cpu);
 	/*
 	 * Deal with CPUs that don't clear their LBRs on power-up.
 	 */
 	intel_pmu_lbr_reset();
 	if (!cpuc->shared_regs || (x86_pmu.er_flags & ERF_NO_HT_SHARING))
 		return;
 	for_each_cpu(i, topology_thread_cpumask(cpu)) {
 		struct intel_shared_regs *pc;
 		pc = per_cpu(cpu_hw_events, i).shared_regs;
 		if (pc && pc->core_id == core_id) {
 			kfree(cpuc->shared_regs);
 			cpuc->shared_regs = pc;
 			break;
 		}
 	}
 	cpuc->shared_regs->core_id = core_id;
 	cpuc->shared_regs->refcnt++;
 }
 static void intel_pmu_cpu_dying(int cpu)
 {
 	struct cpu_hw_events *cpuc = &per_cpu(cpu_hw_events, cpu);
 	struct intel_shared_regs *pc;
 	pc = cpuc->shared_regs;
 	if (pc) {
 		if (pc->core_id == -1 || --pc->refcnt == 0)
 			kfree(pc);
 		cpuc->shared_regs = NULL;
 	}
 	fini_debug_store_on_cpu(cpu);
 }
 static __initconst const struct x86_pmu intel_pmu = {
 	.name			= "Intel",
 	.handle_irq		= intel_pmu_handle_irq,
 	.disable_all		= intel_pmu_disable_all,
 	.enable_all		= intel_pmu_enable_all,
 	.enable			= intel_pmu_enable_event,
 	.disable		= intel_pmu_disable_event,
 	.hw_config		= intel_pmu_hw_config,
 	.schedule_events	= x86_schedule_events,
 	.eventsel		= MSR_ARCH_PERFMON_EVENTSEL0,
 	.perfctr		= MSR_ARCH_PERFMON_PERFCTR0,
 	.event_map		= intel_pmu_event_map,
 	.max_events		= ARRAY_SIZE(intel_perfmon_event_map),
 	.apic			= 1,
 	/*
 	 * Intel PMCs cannot be accessed sanely above 32 bit width,
 	 * so we install an artificial 1<<31 period regardless of
 	 * the generic event period:
 	 */
 	.max_period		= (1ULL << 31) - 1,
 	.get_event_constraints	= intel_get_event_constraints,
 	.put_event_constraints	= intel_put_event_constraints,
 	.cpu_prepare		= intel_pmu_cpu_prepare,
 	.cpu_starting		= intel_pmu_cpu_starting,
 	.cpu_dying		= intel_pmu_cpu_dying,
 };
 static void intel_clovertown_quirks(void)
 {
 	/*
 	 * PEBS is unreliable due to:
 	 *
 	 *   AJ67  - PEBS may experience CPL leaks
 	 *   AJ68  - PEBS PMI may be delayed by one event
 	 *   AJ69  - GLOBAL_STATUS[62] will only be set when DEBUGCTL[12]
 	 *   AJ106 - FREEZE_LBRS_ON_PMI doesn't work in combination with PEBS
 	 *
 	 * AJ67 could be worked around by restricting the OS/USR flags.
 	 * AJ69 could be worked around by setting PMU_FREEZE_ON_PMI.
 	 *
 	 * AJ106 could possibly be worked around by not allowing LBR
 	 *       usage from PEBS, including the fixup.
 	 * AJ68  could possibly be worked around by always programming
 	 *	 a pebs_event_reset[0] value and coping with the lost events.
 	 *
 	 * But taken together it might just make sense to not enable PEBS on
 	 * these chips.
 	 */
 	printk(KERN_WARNING "PEBS disabled due to CPU errata.\n");
 	x86_pmu.pebs = 0;
 	x86_pmu.pebs_constraints = NULL;
 }
 static __init int intel_pmu_init(void)
 {
 	union cpuid10_edx edx;
 	union cpuid10_eax eax;
 	unsigned int unused;
 	unsigned int ebx;
 	int version;
 	if (!cpu_has(&boot_cpu_data, X86_FEATURE_ARCH_PERFMON)) {
 		switch (boot_cpu_data.x86) {
 		case 0x6:
 			return p6_pmu_init();
 		case 0xf:
 			return p4_pmu_init();
 		}
 		return -ENODEV;
 	}
 	/*
 	 * Check whether the Architectural PerfMon supports
 	 * Branch Misses Retired hw_event or not.
 	 */
 	cpuid(10, &eax.full, &ebx, &unused, &edx.full);
 	if (eax.split.mask_length <= ARCH_PERFMON_BRANCH_MISSES_RETIRED)
 		return -ENODEV;
 	version = eax.split.version_id;
 	if (version < 2)
 		x86_pmu = core_pmu;
 	else
 		x86_pmu = intel_pmu;
 	x86_pmu.version			= version;
 	x86_pmu.num_counters		= eax.split.num_counters;
 	x86_pmu.cntval_bits		= eax.split.bit_width;
 	x86_pmu.cntval_mask		= (1ULL << eax.split.bit_width) - 1;
 	/*
 	 * Quirk: v2 perfmon does not report fixed-purpose events, so
 	 * assume at least 3 events:
 	 */
 	if (version > 1)
 		x86_pmu.num_counters_fixed = max((int)edx.split.num_counters_fixed, 3);
 	/*
 	 * v2 and above have a perf capabilities MSR
 	 */
 	if (version > 1) {
 		u64 capabilities;
 		rdmsrl(MSR_IA32_PERF_CAPABILITIES, capabilities);
 		x86_pmu.intel_cap.capabilities = capabilities;
 	}
 	intel_ds_init();
 	/*
 	 * Install the hw-cache-events table:
 	 */
 	switch (boot_cpu_data.x86_model) {
 	case 14: /* 65 nm core solo/duo, "Yonah" */
 		pr_cont("Core events, ");
 		break;
 	case 15: /* original 65 nm celeron/pentium/core2/xeon, "Merom"/"Conroe" */
 		x86_pmu.quirks = intel_clovertown_quirks;
 	case 22: /* single-core 65 nm celeron/core2solo "Merom-L"/"Conroe-L" */
 	case 23: /* current 45 nm celeron/core2/xeon "Penryn"/"Wolfdale" */
 	case 29: /* six-core 45 nm xeon "Dunnington" */
 		memcpy(hw_cache_event_ids, core2_hw_cache_event_ids,
 		       sizeof(hw_cache_event_ids));
 		intel_pmu_lbr_init_core();
 		x86_pmu.event_constraints = intel_core2_event_constraints;
 		x86_pmu.pebs_constraints = intel_core2_pebs_event_constraints;
 		pr_cont("Core2 events, ");
 		break;
 	case 26: /* 45 nm nehalem, "Bloomfield" */
 	case 30: /* 45 nm nehalem, "Lynnfield" */
 	case 46: /* 45 nm nehalem-ex, "Beckton" */
 		memcpy(hw_cache_event_ids, nehalem_hw_cache_event_ids,
 		       sizeof(hw_cache_event_ids));
 		memcpy(hw_cache_extra_regs, nehalem_hw_cache_extra_regs,
 		       sizeof(hw_cache_extra_regs));
 		intel_pmu_lbr_init_nhm();
 		x86_pmu.event_constraints = intel_nehalem_event_constraints;
 		x86_pmu.pebs_constraints = intel_nehalem_pebs_event_constraints;
 		x86_pmu.enable_all = intel_pmu_nhm_enable_all;
 		x86_pmu.extra_regs = intel_nehalem_extra_regs;
 		/* UOPS_ISSUED.STALLED_CYCLES */
 		intel_perfmon_event_map[PERF_COUNT_HW_STALLED_CYCLES_FRONTEND] = 0x180010e;
 		/* UOPS_EXECUTED.CORE_ACTIVE_CYCLES,c=1,i=1 */
 		intel_perfmon_event_map[PERF_COUNT_HW_STALLED_CYCLES_BACKEND] = 0x1803fb1;
 		if (ebx & 0x40) {
 			/*
 			 * Erratum AAJ80 detected, we work it around by using
 			 * the BR_MISP_EXEC.ANY event. This will over-count
 			 * branch-misses, but it's still much better than the
 			 * architectural event which is often completely bogus:
 			 */
 			intel_perfmon_event_map[PERF_COUNT_HW_BRANCH_MISSES] = 0x7f89;
 			pr_cont("erratum AAJ80 worked around, ");
 		}
 		pr_cont("Nehalem events, ");
 		break;
 	case 28: /* Atom */
 		memcpy(hw_cache_event_ids, atom_hw_cache_event_ids,
 		       sizeof(hw_cache_event_ids));
 		intel_pmu_lbr_init_atom();
 		x86_pmu.event_constraints = intel_gen_event_constraints;
 		x86_pmu.pebs_constraints = intel_atom_pebs_event_constraints;
 		pr_cont("Atom events, ");
 		break;
 	case 37: /* 32 nm nehalem, "Clarkdale" */
 	case 44: /* 32 nm nehalem, "Gulftown" */
 	case 47: /* 32 nm Xeon E7 */
 		memcpy(hw_cache_event_ids, westmere_hw_cache_event_ids,
 		       sizeof(hw_cache_event_ids));
 		memcpy(hw_cache_extra_regs, nehalem_hw_cache_extra_regs,
 		       sizeof(hw_cache_extra_regs));
 		intel_pmu_lbr_init_nhm();
 		x86_pmu.event_constraints = intel_westmere_event_constraints;
 		x86_pmu.enable_all = intel_pmu_nhm_enable_all;
 		x86_pmu.pebs_constraints = intel_westmere_pebs_event_constraints;
 		x86_pmu.extra_regs = intel_westmere_extra_regs;
 		x86_pmu.er_flags |= ERF_HAS_RSP_1;
 		/* UOPS_ISSUED.STALLED_CYCLES */
 		intel_perfmon_event_map[PERF_COUNT_HW_STALLED_CYCLES_FRONTEND] = 0x180010e;
 		/* UOPS_EXECUTED.CORE_ACTIVE_CYCLES,c=1,i=1 */
 		intel_perfmon_event_map[PERF_COUNT_HW_STALLED_CYCLES_BACKEND] = 0x1803fb1;
 		pr_cont("Westmere events, ");
 		break;
 	case 42: /* SandyBridge */
+	case 45: /* SandyBridge, "Romely-EP" */
 		memcpy(hw_cache_event_ids, snb_hw_cache_event_ids,
 		       sizeof(hw_cache_event_ids));
 		intel_pmu_lbr_init_nhm();
 		x86_pmu.event_constraints = intel_snb_event_constraints;
 		x86_pmu.pebs_constraints = intel_snb_pebs_events;
 		x86_pmu.extra_regs = intel_snb_extra_regs;
 		/* all extra regs are per-cpu when HT is on */
 		x86_pmu.er_flags |= ERF_HAS_RSP_1;
 		x86_pmu.er_flags |= ERF_NO_HT_SHARING;
 		/* UOPS_ISSUED.ANY,c=1,i=1 to count stall cycles */
 		intel_perfmon_event_map[PERF_COUNT_HW_STALLED_CYCLES_FRONTEND] = 0x180010e;
 		/* UOPS_DISPATCHED.THREAD,c=1,i=1 to count stall cycles*/
 		intel_perfmon_event_map[PERF_COUNT_HW_STALLED_CYCLES_BACKEND] = 0x18001b1;
 		pr_cont("SandyBridge events, ");
 		break;
 	default:
 		switch (x86_pmu.version) {
 		case 1:
 			x86_pmu.event_constraints = intel_v1_event_constraints;
 			pr_cont("generic architected perfmon v1, ");
 			break;
 		default:
 			/*
 			 * default constraints for v2 and up
 			 */
 			x86_pmu.event_constraints = intel_gen_event_constraints;
 			pr_cont("generic architected perfmon, ");
 			break;
 		}
 	}
 	return 0;
 }
 #else /* CONFIG_CPU_SUP_INTEL */
 static int intel_pmu_init(void)
 {
 	return 0;
 }
 static struct intel_shared_regs *allocate_shared_regs(int cpu)
 {
 	return NULL;
 }
 #endif /* CONFIG_CPU_SUP_INTEL */

kernel/Makefile

Diff comments View file @ 1d229d5

 #
 # Makefile for the linux kernel.
 #
 obj-y     = sched.o fork.o exec_domain.o panic.o printk.o \
 	    cpu.o exit.o itimer.o time.o softirq.o resource.o \
 	    sysctl.o sysctl_binary.o capability.o ptrace.o timer.o user.o \
 	    signal.o sys.o kmod.o workqueue.o pid.o \
 	    rcupdate.o extable.o params.o posix-timers.o \
 	    kthread.o wait.o kfifo.o sys_ni.o posix-cpu-timers.o mutex.o \
 	    hrtimer.o rwsem.o nsproxy.o srcu.o semaphore.o \
 	    notifier.o ksysfs.o pm_qos_params.o sched_clock.o cred.o \
-	    async.o range.o jump_label.o
+	    async.o range.o
 obj-y += groups.o
 ifdef CONFIG_FUNCTION_TRACER
 # Do not trace debug files and internal ftrace files
 CFLAGS_REMOVE_lockdep.o = -pg
 CFLAGS_REMOVE_lockdep_proc.o = -pg
 CFLAGS_REMOVE_mutex-debug.o = -pg
 CFLAGS_REMOVE_rtmutex-debug.o = -pg
 CFLAGS_REMOVE_cgroup-debug.o = -pg
 CFLAGS_REMOVE_sched_clock.o = -pg
 CFLAGS_REMOVE_irq_work.o = -pg
 endif
 obj-$(CONFIG_FREEZER) += freezer.o
 obj-$(CONFIG_PROFILING) += profile.o
 obj-$(CONFIG_SYSCTL_SYSCALL_CHECK) += sysctl_check.o
 obj-$(CONFIG_STACKTRACE) += stacktrace.o
 obj-y += time/
 obj-$(CONFIG_DEBUG_MUTEXES) += mutex-debug.o
 obj-$(CONFIG_LOCKDEP) += lockdep.o
 ifeq ($(CONFIG_PROC_FS),y)
 obj-$(CONFIG_LOCKDEP) += lockdep_proc.o
 endif
 obj-$(CONFIG_FUTEX) += futex.o
 ifeq ($(CONFIG_COMPAT),y)
 obj-$(CONFIG_FUTEX) += futex_compat.o
 endif
 obj-$(CONFIG_RT_MUTEXES) += rtmutex.o
 obj-$(CONFIG_DEBUG_RT_MUTEXES) += rtmutex-debug.o
 obj-$(CONFIG_RT_MUTEX_TESTER) += rtmutex-tester.o
 obj-$(CONFIG_GENERIC_ISA_DMA) += dma.o
 obj-$(CONFIG_SMP) += smp.o
 ifneq ($(CONFIG_SMP),y)
 obj-y += up.o
 endif
 obj-$(CONFIG_SMP) += spinlock.o
 obj-$(CONFIG_DEBUG_SPINLOCK) += spinlock.o
 obj-$(CONFIG_PROVE_LOCKING) += spinlock.o
 obj-$(CONFIG_UID16) += uid16.o
 obj-$(CONFIG_MODULES) += module.o
 obj-$(CONFIG_KALLSYMS) += kallsyms.o
 obj-$(CONFIG_PM) += power/
 obj-$(CONFIG_FREEZER) += power/
 obj-$(CONFIG_BSD_PROCESS_ACCT) += acct.o
 obj-$(CONFIG_KEXEC) += kexec.o
 obj-$(CONFIG_BACKTRACE_SELF_TEST) += backtracetest.o
 obj-$(CONFIG_COMPAT) += compat.o
 obj-$(CONFIG_CGROUPS) += cgroup.o
 obj-$(CONFIG_CGROUP_FREEZER) += cgroup_freezer.o
 obj-$(CONFIG_CPUSETS) += cpuset.o
 obj-$(CONFIG_UTS_NS) += utsname.o
 obj-$(CONFIG_USER_NS) += user_namespace.o
 obj-$(CONFIG_PID_NS) += pid_namespace.o
 obj-$(CONFIG_IKCONFIG) += configs.o
 obj-$(CONFIG_RESOURCE_COUNTERS) += res_counter.o
 obj-$(CONFIG_SMP) += stop_machine.o
 obj-$(CONFIG_KPROBES_SANITY_TEST) += test_kprobes.o
 obj-$(CONFIG_AUDIT) += audit.o auditfilter.o
 obj-$(CONFIG_AUDITSYSCALL) += auditsc.o
 obj-$(CONFIG_AUDIT_WATCH) += audit_watch.o
 obj-$(CONFIG_AUDIT_TREE) += audit_tree.o
 obj-$(CONFIG_GCOV_KERNEL) += gcov/
 obj-$(CONFIG_KPROBES) += kprobes.o
 obj-$(CONFIG_KGDB) += debug/
 obj-$(CONFIG_DETECT_HUNG_TASK) += hung_task.o
 obj-$(CONFIG_LOCKUP_DETECTOR) += watchdog.o
 obj-$(CONFIG_GENERIC_HARDIRQS) += irq/
 obj-$(CONFIG_SECCOMP) += seccomp.o
 obj-$(CONFIG_RCU_TORTURE_TEST) += rcutorture.o
 obj-$(CONFIG_TREE_RCU) += rcutree.o
 obj-$(CONFIG_TREE_PREEMPT_RCU) += rcutree.o
 obj-$(CONFIG_TREE_RCU_TRACE) += rcutree_trace.o
 obj-$(CONFIG_TINY_RCU) += rcutiny.o
 obj-$(CONFIG_TINY_PREEMPT_RCU) += rcutiny.o
 obj-$(CONFIG_RELAY) += relay.o
 obj-$(CONFIG_SYSCTL) += utsname_sysctl.o
 obj-$(CONFIG_TASK_DELAY_ACCT) += delayacct.o
 obj-$(CONFIG_TASKSTATS) += taskstats.o tsacct.o
 obj-$(CONFIG_TRACEPOINTS) += tracepoint.o
 obj-$(CONFIG_LATENCYTOP) += latencytop.o
 obj-$(CONFIG_BINFMT_ELF) += elfcore.o
 obj-$(CONFIG_COMPAT_BINFMT_ELF) += elfcore.o
 obj-$(CONFIG_BINFMT_ELF_FDPIC) += elfcore.o
 obj-$(CONFIG_FUNCTION_TRACER) += trace/
 obj-$(CONFIG_TRACING) += trace/
 obj-$(CONFIG_X86_DS) += trace/
 obj-$(CONFIG_RING_BUFFER) += trace/
 obj-$(CONFIG_TRACEPOINTS) += trace/
 obj-$(CONFIG_SMP) += sched_cpupri.o
 obj-$(CONFIG_IRQ_WORK) += irq_work.o
 obj-$(CONFIG_PERF_EVENTS) += events/
 obj-$(CONFIG_USER_RETURN_NOTIFIER) += user-return-notifier.o
 obj-$(CONFIG_PADATA) += padata.o
 obj-$(CONFIG_CRASH_DUMP) += crash_dump.o
+obj-$(CONFIG_JUMP_LABEL) += jump_label.o
 ifneq ($(CONFIG_SCHED_OMIT_FRAME_POINTER),y)
 # According to Alan Modra <alan@linuxcare.com.au>, the -fno-omit-frame-pointer is
 # needed for x86 only.  Why this used to be enabled for all architectures is beyond
 # me.  I suspect most platforms don't need this, but until we know that for sure
 # I turn this off for IA-64 only.  Andreas Schwab says it's also needed on m68k
 # to get a correct value for the wait-channel (WCHAN in ps). --davidm
 CFLAGS_sched.o := $(PROFILING) -fno-omit-frame-pointer
 endif
 $(obj)/configs.o: $(obj)/config_data.h
 # config_data.h contains the same information as ikconfig.h but gzipped.
 # Info from config_data can be extracted from /proc/config*
 targets += config_data.gz
 $(obj)/config_data.gz: $(KCONFIG_CONFIG) FORCE
 	$(call if_changed,gzip)
       filechk_ikconfiggz = (echo "static const char kernel_config_data[] __used = MAGIC_START"; cat $< | scripts/bin2c; echo "MAGIC_END;")
 targets += config_data.h
 $(obj)/config_data.h: $(obj)/config_data.gz FORCE
 	$(call filechk,ikconfiggz)
 $(obj)/time.o: $(obj)/timeconst.h
 quiet_cmd_timeconst  = TIMEC   $@
       cmd_timeconst  = $(PERL) $< $(CONFIG_HZ) > $@
 targets += timeconst.h
 $(obj)/timeconst.h: $(src)/timeconst.pl FORCE
 	$(call if_changed,timeconst)

kernel/trace/Kconfig

Diff comments View file @ 1d229d5

tools/perf/Makefile

Diff comments View file @ 1d229d5

 ifeq ("$(origin O)", "command line")
 	OUTPUT := $(O)/
 endif
 # The default target of this Makefile is...
 all:
 include config/utilities.mak
 ifneq ($(OUTPUT),)
 # check that the output directory actually exists
 OUTDIR := $(shell cd $(OUTPUT) && /bin/pwd)
 $(if $(OUTDIR),, $(error output directory "$(OUTPUT)" does not exist))
 endif
 # Define V to have a more verbose compile.
 #
 # 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.
 $(OUTPUT)PERF-VERSION-FILE: .FORCE-PERF-VERSION-FILE
 	@$(SHELL_PATH) util/PERF-VERSION-GEN $(OUTPUT)
 -include $(OUTPUT)PERF-VERSION-FILE
 uname_M := $(shell uname -m 2>/dev/null || echo not)
 ARCH ?= $(shell echo $(uname_M) | sed -e s/i.86/i386/ -e s/sun4u/sparc64/ \
 				  -e s/arm.*/arm/ -e s/sa110/arm/ \
 				  -e s/s390x/s390/ -e s/parisc64/parisc/ \
 				  -e s/ppc.*/powerpc/ -e s/mips.*/mips/ \
 				  -e s/sh[234].*/sh/ )
 CC = $(CROSS_COMPILE)gcc
 AR = $(CROSS_COMPILE)ar
 # Additional ARCH settings for x86
 ifeq ($(ARCH),i386)
         ARCH := x86
 endif
 ifeq ($(ARCH),x86_64)
 	ARCH := x86
 	IS_X86_64 := 0
 	ifeq (, $(findstring m32,$(EXTRA_CFLAGS)))
 		IS_X86_64 := $(shell echo __x86_64__ | ${CC} -E -xc - | tail -n 1)
 	endif
 	ifeq (${IS_X86_64}, 1)
 		RAW_ARCH := x86_64
 		ARCH_CFLAGS := -DARCH_X86_64
 		ARCH_INCLUDE = ../../arch/x86/lib/memcpy_64.S
 	endif
 endif
 #
 # Include saner warnings here, which can catch bugs:
 #
 EXTRA_WARNINGS := -Wformat
 EXTRA_WARNINGS := $(EXTRA_WARNINGS) -Wformat-security
 EXTRA_WARNINGS := $(EXTRA_WARNINGS) -Wformat-y2k
 EXTRA_WARNINGS := $(EXTRA_WARNINGS) -Wshadow
 EXTRA_WARNINGS := $(EXTRA_WARNINGS) -Winit-self
 EXTRA_WARNINGS := $(EXTRA_WARNINGS) -Wpacked
 EXTRA_WARNINGS := $(EXTRA_WARNINGS) -Wredundant-decls
 EXTRA_WARNINGS := $(EXTRA_WARNINGS) -Wstrict-aliasing=3
 EXTRA_WARNINGS := $(EXTRA_WARNINGS) -Wswitch-default
 EXTRA_WARNINGS := $(EXTRA_WARNINGS) -Wswitch-enum
 EXTRA_WARNINGS := $(EXTRA_WARNINGS) -Wno-system-headers
 EXTRA_WARNINGS := $(EXTRA_WARNINGS) -Wundef
 EXTRA_WARNINGS := $(EXTRA_WARNINGS) -Wwrite-strings
 EXTRA_WARNINGS := $(EXTRA_WARNINGS) -Wbad-function-cast
 EXTRA_WARNINGS := $(EXTRA_WARNINGS) -Wmissing-declarations
 EXTRA_WARNINGS := $(EXTRA_WARNINGS) -Wmissing-prototypes
 EXTRA_WARNINGS := $(EXTRA_WARNINGS) -Wnested-externs
 EXTRA_WARNINGS := $(EXTRA_WARNINGS) -Wold-style-definition
 EXTRA_WARNINGS := $(EXTRA_WARNINGS) -Wstrict-prototypes
 EXTRA_WARNINGS := $(EXTRA_WARNINGS) -Wdeclaration-after-statement
 ifeq ("$(origin DEBUG)", "command line")
   PERF_DEBUG = $(DEBUG)
 endif
 ifndef PERF_DEBUG
   CFLAGS_OPTIMIZE = -O6
 endif
 CFLAGS = -fno-omit-frame-pointer -ggdb3 -Wall -Wextra -std=gnu99 -Werror $(CFLAGS_OPTIMIZE) -D_FORTIFY_SOURCE=2 $(EXTRA_WARNINGS) $(EXTRA_CFLAGS)
 EXTLIBS = -lpthread -lrt -lelf -lm
 ALL_CFLAGS = $(CFLAGS) -D_LARGEFILE64_SOURCE -D_FILE_OFFSET_BITS=64
 ALL_LDFLAGS = $(LDFLAGS)
 STRIP ?= strip
 # Among the variables below, these:
 #   perfexecdir
 #   template_dir
 #   mandir
 #   infodir
 #   htmldir
 #   ETC_PERFCONFIG (but not sysconfdir)
 # can be specified as a relative path some/where/else;
 # this is interpreted as relative to $(prefix) and "perf" at
 # runtime figures out where they are based on the path to the executable.
 # This can help installing the suite in a relocatable way.
 # Make the path relative to DESTDIR, not to prefix
 ifndef DESTDIR
 prefix = $(HOME)
 endif
 bindir_relative = bin
 bindir = $(prefix)/$(bindir_relative)
 mandir = share/man
 infodir = share/info
 perfexecdir = libexec/perf-core
 sharedir = $(prefix)/share
 template_dir = share/perf-core/templates
 htmldir = share/doc/perf-doc
 ifeq ($(prefix),/usr)
 sysconfdir = /etc
 ETC_PERFCONFIG = $(sysconfdir)/perfconfig
 else
 sysconfdir = $(prefix)/etc
 ETC_PERFCONFIG = etc/perfconfig
 endif
 lib = lib
 export prefix bindir sharedir sysconfdir
 RM = rm -f
 MKDIR = mkdir
 FIND = find
 INSTALL = install
 # 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__
 -include config/feature-tests.mak
 ifeq ($(call try-cc,$(SOURCE_HELLO),-Werror -fstack-protector-all),y)
 	CFLAGS := $(CFLAGS) -fstack-protector-all
 endif
 ifeq ($(call try-cc,$(SOURCE_HELLO),-Werror -Wstack-protector),y)
        CFLAGS := $(CFLAGS) -Wstack-protector
 endif
 ifeq ($(call try-cc,$(SOURCE_HELLO),-Werror -Wvolatile-register-var),y)
        CFLAGS := $(CFLAGS) -Wvolatile-register-var
 endif
 ### --- END CONFIGURATION SECTION ---
 # Those must not be GNU-specific; they are shared with perl/ which may
 # be built by a different compiler. (Note that this is an artifact now
 # but it still might be nice to keep that distinction.)
 BASIC_CFLAGS = -Iutil/include -Iarch/$(ARCH)/include
 BASIC_LDFLAGS =
 # Guard against environment variables
 BUILTIN_OBJS =
 LIB_H =
 LIB_OBJS =
 PYRF_OBJS =
 SCRIPT_SH =
 SCRIPT_SH += perf-archive.sh
 grep-libs = $(filter -l%,$(1))
 strip-libs = $(filter-out -l%,$(1))
 $(OUTPUT)python/perf.so: $(PYRF_OBJS)
 	$(QUIET_GEN)CFLAGS='$(BASIC_CFLAGS)' $(PYTHON_WORD) util/setup.py \
-	  --quiet build_ext \
+	  --quiet build_ext; \
-	  --build-lib='$(OUTPUT)python' \
+	mkdir -p $(OUTPUT)python && \
-	  --build-temp='$(OUTPUT)python/temp'
+	cp $(PYTHON_EXTBUILD_LIB)perf.so $(OUTPUT)python/
 #
 # No Perl scripts right now:
 #
 SCRIPTS = $(patsubst %.sh,%,$(SCRIPT_SH))
 #
 # Single 'perf' binary right now:
 #
 PROGRAMS += $(OUTPUT)perf
 LANG_BINDINGS =
 # 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
 LIB_FILE=$(OUTPUT)libperf.a
 LIB_H += ../../include/linux/perf_event.h
 LIB_H += ../../include/linux/rbtree.h
 LIB_H += ../../include/linux/list.h
 LIB_H += ../../include/linux/const.h
 LIB_H += ../../include/linux/hash.h
 LIB_H += ../../include/linux/stringify.h
 LIB_H += util/include/linux/bitmap.h
 LIB_H += util/include/linux/bitops.h
 LIB_H += util/include/linux/compiler.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 += util/include/linux/module.h
 LIB_H += util/include/linux/poison.h
 LIB_H += util/include/linux/prefetch.h
 LIB_H += util/include/linux/rbtree.h
 LIB_H += util/include/linux/string.h
 LIB_H += util/include/linux/types.h
 LIB_H += util/include/linux/linkage.h
 LIB_H += util/include/asm/asm-offsets.h
 LIB_H += util/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 += 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/debug.h
 LIB_H += util/debugfs.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/types.h
 LIB_H += util/levenshtein.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/strbuf.h
 LIB_H += util/strlist.h
 LIB_H += util/strfilter.h
 LIB_H += util/svghelper.h
 LIB_H += util/run-command.h
 LIB_H += util/sigchain.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/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_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/debugfs.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/help.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/symbol.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/map.o
 LIB_OBJS += $(OUTPUT)util/pstack.o
 LIB_OBJS += $(OUTPUT)util/session.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/trace-event-read.o
 LIB_OBJS += $(OUTPUT)util/trace-event-info.o
 LIB_OBJS += $(OUTPUT)util/trace-event-scripting.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
 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)
 BUILTIN_OBJS += $(OUTPUT)bench/mem-memcpy-x86-64-asm.o
 endif
 BUILTIN_OBJS += $(OUTPUT)bench/mem-memcpy.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-test.o
 BUILTIN_OBJS += $(OUTPUT)builtin-inject.o
 PERFLIBS = $(LIB_FILE)
 # Files needed for the python binding, perf.so
 # pyrf is just an internal name needed for all those wrappers.
 # This has to be in sync with what is in the 'sources' variable in
 # tools/perf/util/setup.py
 PYRF_OBJS += $(OUTPUT)util/cpumap.o
 PYRF_OBJS += $(OUTPUT)util/ctype.o
 PYRF_OBJS += $(OUTPUT)util/evlist.o
 PYRF_OBJS += $(OUTPUT)util/evsel.o
 PYRF_OBJS += $(OUTPUT)util/python.o
 PYRF_OBJS += $(OUTPUT)util/thread_map.o
 PYRF_OBJS += $(OUTPUT)util/util.o
 PYRF_OBJS += $(OUTPUT)util/xyarray.o
 #
 # Platform specific tweaks
 #
 # 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 config.mak.autogen
 -include config.mak
 ifndef NO_DWARF
 FLAGS_DWARF=$(ALL_CFLAGS) -ldw -lelf $(ALL_LDFLAGS) $(EXTLIBS)
 ifneq ($(call try-cc,$(SOURCE_DWARF),$(FLAGS_DWARF)),y)
 	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);
 	NO_DWARF := 1
 endif # Dwarf support
 endif # NO_DWARF
 -include arch/$(ARCH)/Makefile
 ifneq ($(OUTPUT),)
 	BASIC_CFLAGS += -I$(OUTPUT)
 endif
 FLAGS_LIBELF=$(ALL_CFLAGS) $(ALL_LDFLAGS) $(EXTLIBS)
 ifneq ($(call try-cc,$(SOURCE_LIBELF),$(FLAGS_LIBELF)),y)
 	FLAGS_GLIBC=$(ALL_CFLAGS) $(ALL_LDFLAGS)
 	ifneq ($(call try-cc,$(SOURCE_GLIBC),$(FLAGS_GLIBC)),y)
 		msg := $(error No gnu/libc-version.h found, please install glibc-dev[el]/glibc-static);
 	else
 		msg := $(error No libelf.h/libelf found, please install libelf-dev/elfutils-libelf-devel);
 	endif
 endif
 ifneq ($(call try-cc,$(SOURCE_ELF_MMAP),$(FLAGS_COMMON)),y)
 	BASIC_CFLAGS += -DLIBELF_NO_MMAP
 endif
 ifndef NO_DWARF
 ifeq ($(origin PERF_HAVE_DWARF_REGS), undefined)
 	msg := $(warning DWARF register mappings have not been defined for architecture $(ARCH), DWARF support disabled);
 else
 	BASIC_CFLAGS += -DDWARF_SUPPORT
 	EXTLIBS += -lelf -ldw
 	LIB_OBJS += $(OUTPUT)util/probe-finder.o
 	LIB_OBJS += $(OUTPUT)util/dwarf-aux.o
 endif # PERF_HAVE_DWARF_REGS
 endif # NO_DWARF
 ifdef NO_NEWT
 	BASIC_CFLAGS += -DNO_NEWT_SUPPORT
 else
 	FLAGS_NEWT=$(ALL_CFLAGS) $(ALL_LDFLAGS) $(EXTLIBS) -lnewt
 	ifneq ($(call try-cc,$(SOURCE_NEWT),$(FLAGS_NEWT)),y)
 		msg := $(warning newt not found, disables TUI support. Please install newt-devel or libnewt-dev);
 		BASIC_CFLAGS += -DNO_NEWT_SUPPORT
 	else
 		# Fedora has /usr/include/slang/slang.h, but ubuntu /usr/include/slang.h
 		BASIC_CFLAGS += -I/usr/include/slang
 		EXTLIBS += -lnewt -lslang
 		LIB_OBJS += $(OUTPUT)util/ui/setup.o
 		LIB_OBJS += $(OUTPUT)util/ui/browser.o
 		LIB_OBJS += $(OUTPUT)util/ui/browsers/annotate.o
 		LIB_OBJS += $(OUTPUT)util/ui/browsers/hists.o
 		LIB_OBJS += $(OUTPUT)util/ui/browsers/map.o
 		LIB_OBJS += $(OUTPUT)util/ui/browsers/top.o
 		LIB_OBJS += $(OUTPUT)util/ui/helpline.o
 		LIB_OBJS += $(OUTPUT)util/ui/progress.o
 		LIB_OBJS += $(OUTPUT)util/ui/util.o
 		LIB_H += util/ui/browser.h
 		LIB_H += util/ui/browsers/map.h
 		LIB_H += util/ui/helpline.h
 		LIB_H += util/ui/libslang.h
 		LIB_H += util/ui/progress.h
 		LIB_H += util/ui/util.h
 		LIB_H += util/ui/ui.h
 	endif
 endif
 ifdef NO_LIBPERL
 	BASIC_CFLAGS += -DNO_LIBPERL
 else
        PERL_EMBED_LDOPTS = $(shell perl -MExtUtils::Embed -e ldopts 2>/dev/null)
        PERL_EMBED_LDFLAGS = $(call strip-libs,$(PERL_EMBED_LDOPTS))
        PERL_EMBED_LIBADD = $(call grep-libs,$(PERL_EMBED_LDOPTS))
 	PERL_EMBED_CCOPTS = `perl -MExtUtils::Embed -e ccopts 2>/dev/null`
 	FLAGS_PERL_EMBED=$(PERL_EMBED_CCOPTS) $(PERL_EMBED_LDOPTS)
 	ifneq ($(call try-cc,$(SOURCE_PERL_EMBED),$(FLAGS_PERL_EMBED)),y)
 		BASIC_CFLAGS += -DNO_LIBPERL
 	else
                ALL_LDFLAGS += $(PERL_EMBED_LDFLAGS)
                EXTLIBS += $(PERL_EMBED_LIBADD)
 		LIB_OBJS += $(OUTPUT)util/scripting-engines/trace-event-perl.o
 		LIB_OBJS += $(OUTPUT)scripts/perl/Perf-Trace-Util/Context.o
 	endif
 endif
 disable-python = $(eval $(disable-python_code))
 define disable-python_code
   BASIC_CFLAGS += -DNO_LIBPYTHON
   $(if $(1),$(warning No $(1) was found))
   $(warning Python support won't be built)
 endef
 override PYTHON := \
   $(call get-executable-or-default,PYTHON,python)
 ifndef PYTHON
   $(call disable-python,python interpreter)
   python-clean :=
 else
   PYTHON_WORD := $(call shell-wordify,$(PYTHON))
-  python-clean := $(PYTHON_WORD) util/setup.py clean \
+  # python extension build directories
-    --build-lib='$(OUTPUT)python' \
+  PYTHON_EXTBUILD     := $(OUTPUT)python_ext_build/
-    --build-temp='$(OUTPUT)python/temp'
+  PYTHON_EXTBUILD_LIB := $(PYTHON_EXTBUILD)lib/
+  PYTHON_EXTBUILD_TMP := $(PYTHON_EXTBUILD)tmp/
+  export PYTHON_EXTBUILD_LIB PYTHON_EXTBUILD_TMP
+  python-clean := rm -rf $(PYTHON_EXTBUILD) $(OUTPUT)python/perf.so
   ifdef NO_LIBPYTHON
     $(call disable-python)
   else
     override PYTHON_CONFIG := \
       $(call get-executable-or-default,PYTHON_CONFIG,$(PYTHON)-config)
     ifndef PYTHON_CONFIG
       $(call disable-python,python-config tool)
     else
       PYTHON_CONFIG_SQ := $(call shell-sq,$(PYTHON_CONFIG))
       PYTHON_EMBED_LDOPTS := $(shell $(PYTHON_CONFIG_SQ) --ldflags 2>/dev/null)
       PYTHON_EMBED_LDFLAGS := $(call strip-libs,$(PYTHON_EMBED_LDOPTS))
       PYTHON_EMBED_LIBADD := $(call grep-libs,$(PYTHON_EMBED_LDOPTS))
       PYTHON_EMBED_CCOPTS := $(shell $(PYTHON_CONFIG_SQ) --cflags 2>/dev/null)
       FLAGS_PYTHON_EMBED := $(PYTHON_EMBED_CCOPTS) $(PYTHON_EMBED_LDOPTS)
       ifneq ($(call try-cc,$(SOURCE_PYTHON_EMBED),$(FLAGS_PYTHON_EMBED)),y)
         $(call disable-python,Python.h (for Python 2.x))
       else
         ifneq ($(call try-cc,$(SOURCE_PYTHON_VERSION),$(FLAGS_PYTHON_EMBED)),y)
           $(warning Python 3 is not yet supported; please set)
           $(warning PYTHON and/or PYTHON_CONFIG appropriately.)
           $(warning If you also have Python 2 installed, then)
           $(warning try something like:)
           $(warning $(and ,))
           $(warning $(and ,)  make PYTHON=python2)
           $(warning $(and ,))
           $(warning Otherwise, disable Python support entirely:)
           $(warning $(and ,))
           $(warning $(and ,)  make NO_LIBPYTHON=1)
           $(warning $(and ,))
           $(error   $(and ,))
         else
           ALL_LDFLAGS += $(PYTHON_EMBED_LDFLAGS)
           EXTLIBS += $(PYTHON_EMBED_LIBADD)
           LIB_OBJS += $(OUTPUT)util/scripting-engines/trace-event-python.o
           LIB_OBJS += $(OUTPUT)scripts/python/Perf-Trace-Util/Context.o
           LANG_BINDINGS += $(OUTPUT)python/perf.so
         endif
       endif
     endif
   endif
 endif
 ifdef NO_DEMANGLE
 	BASIC_CFLAGS += -DNO_DEMANGLE
 else
         ifdef HAVE_CPLUS_DEMANGLE
 		EXTLIBS += -liberty
 		BASIC_CFLAGS += -DHAVE_CPLUS_DEMANGLE
         else
 		FLAGS_BFD=$(ALL_CFLAGS) $(ALL_LDFLAGS) $(EXTLIBS) -lbfd
 		has_bfd := $(call try-cc,$(SOURCE_BFD),$(FLAGS_BFD))
 		ifeq ($(has_bfd),y)
 			EXTLIBS += -lbfd
 		else
 			FLAGS_BFD_IBERTY=$(FLAGS_BFD) -liberty
 			has_bfd_iberty := $(call try-cc,$(SOURCE_BFD),$(FLAGS_BFD_IBERTY))
 			ifeq ($(has_bfd_iberty),y)
 				EXTLIBS += -lbfd -liberty
 			else
 				FLAGS_BFD_IBERTY_Z=$(FLAGS_BFD_IBERTY) -lz
 				has_bfd_iberty_z := $(call try-cc,$(SOURCE_BFD),$(FLAGS_BFD_IBERTY_Z))
 				ifeq ($(has_bfd_iberty_z),y)
 					EXTLIBS += -lbfd -liberty -lz
 				else
 					FLAGS_CPLUS_DEMANGLE=$(ALL_CFLAGS) $(ALL_LDFLAGS) $(EXTLIBS) -liberty
 					has_cplus_demangle := $(call try-cc,$(SOURCE_CPLUS_DEMANGLE),$(FLAGS_CPLUS_DEMANGLE))
 					ifeq ($(has_cplus_demangle),y)
 						EXTLIBS += -liberty
 						BASIC_CFLAGS += -DHAVE_CPLUS_DEMANGLE
 					else
 						msg := $(warning No bfd.h/libbfd found, install binutils-dev[el]/zlib-static to gain symbol demangling)
 						BASIC_CFLAGS += -DNO_DEMANGLE
 					endif
 				endif
 			endif
 		endif
 	endif
 endif
 ifdef NO_STRLCPY
 	BASIC_CFLAGS += -DNO_STRLCPY
 else
 	ifneq ($(call try-cc,$(SOURCE_STRLCPY),),y)
 		BASIC_CFLAGS += -DNO_STRLCPY
 	endif
 endif
 ifneq ($(findstring $(MAKEFLAGS),s),s)
 ifndef V
 	QUIET_CC       = @echo '   ' CC $@;
 	QUIET_AR       = @echo '   ' AR $@;
 	QUIET_LINK     = @echo '   ' LINK $@;
 	QUIET_MKDIR    = @echo '   ' MKDIR $@;
 	QUIET_GEN      = @echo '   ' GEN $@;
 endif
 endif
 ifdef ASCIIDOC8
 	export ASCIIDOC8
 endif
 # Shell quote (do not use $(call) to accommodate ancient setups);
 ETC_PERFCONFIG_SQ = $(subst ','\'',$(ETC_PERFCONFIG))
 DESTDIR_SQ = $(subst ','\'',$(DESTDIR))
 bindir_SQ = $(subst ','\'',$(bindir))
 bindir_relative_SQ = $(subst ','\'',$(bindir_relative))
 mandir_SQ = $(subst ','\'',$(mandir))
 infodir_SQ = $(subst ','\'',$(infodir))
 perfexecdir_SQ = $(subst ','\'',$(perfexecdir))
 template_dir_SQ = $(subst ','\'',$(template_dir))
 htmldir_SQ = $(subst ','\'',$(htmldir))
 prefix_SQ = $(subst ','\'',$(prefix))
 SHELL_PATH_SQ = $(subst ','\'',$(SHELL_PATH))
 LIBS = -Wl,--whole-archive $(PERFLIBS) -Wl,--no-whole-archive -Wl,--start-group $(EXTLIBS) -Wl,--end-group
 ALL_CFLAGS += $(BASIC_CFLAGS)
 ALL_CFLAGS += $(ARCH_CFLAGS)
 ALL_LDFLAGS += $(BASIC_LDFLAGS)
 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) -DPERF_VERSION='"$(PERF_VERSION)"' \
 		'-DPERF_HTML_PATH="$(htmldir_SQ)"' \
 		$(ALL_CFLAGS) -c $(filter %.c,$^) -o $@
 $(OUTPUT)perf: $(OUTPUT)perf.o $(BUILTIN_OBJS) $(PERFLIBS)
 	$(QUIET_LINK)$(CC) $(ALL_CFLAGS) $(ALL_LDFLAGS) $(OUTPUT)perf.o \
                $(BUILTIN_OBJS) $(LIBS) -o $@
 $(OUTPUT)builtin-help.o: builtin-help.c $(OUTPUT)common-cmds.h $(OUTPUT)PERF-CFLAGS
 	$(QUIET_CC)$(CC) -o $@ -c $(ALL_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 $(ALL_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
 $(OUTPUT)%.o: %.c $(OUTPUT)PERF-CFLAGS
 	$(QUIET_CC)$(CC) -o $@ -c $(ALL_CFLAGS) $<
 $(OUTPUT)%.s: %.c $(OUTPUT)PERF-CFLAGS
 	$(QUIET_CC)$(CC) -S $(ALL_CFLAGS) $<
 $(OUTPUT)%.o: %.S
 	$(QUIET_CC)$(CC) -o $@ -c $(ALL_CFLAGS) $<
 $(OUTPUT)util/exec_cmd.o: util/exec_cmd.c $(OUTPUT)PERF-CFLAGS
 	$(QUIET_CC)$(CC) -o $@ -c $(ALL_CFLAGS) \
 		'-DPERF_EXEC_PATH="$(perfexecdir_SQ)"' \
 		'-DBINDIR="$(bindir_relative_SQ)"' \
 		'-DPREFIX="$(prefix_SQ)"' \
 		$<
 $(OUTPUT)util/config.o: util/config.c $(OUTPUT)PERF-CFLAGS
 	$(QUIET_CC)$(CC) -o $@ -c $(ALL_CFLAGS) -DETC_PERFCONFIG='"$(ETC_PERFCONFIG_SQ)"' $<
 $(OUTPUT)util/ui/browser.o: util/ui/browser.c $(OUTPUT)PERF-CFLAGS
 	$(QUIET_CC)$(CC) -o $@ -c $(ALL_CFLAGS) -DENABLE_SLFUTURE_CONST $<
 $(OUTPUT)util/ui/browsers/annotate.o: util/ui/browsers/annotate.c $(OUTPUT)PERF-CFLAGS
 	$(QUIET_CC)$(CC) -o $@ -c $(ALL_CFLAGS) -DENABLE_SLFUTURE_CONST $<
 $(OUTPUT)util/ui/browsers/top.o: util/ui/browsers/top.c $(OUTPUT)PERF-CFLAGS
 	$(QUIET_CC)$(CC) -o $@ -c $(ALL_CFLAGS) -DENABLE_SLFUTURE_CONST $<
 $(OUTPUT)util/ui/browsers/hists.o: util/ui/browsers/hists.c $(OUTPUT)PERF-CFLAGS
 	$(QUIET_CC)$(CC) -o $@ -c $(ALL_CFLAGS) -DENABLE_SLFUTURE_CONST $<
 $(OUTPUT)util/ui/browsers/map.o: util/ui/browsers/map.c $(OUTPUT)PERF-CFLAGS
 	$(QUIET_CC)$(CC) -o $@ -c $(ALL_CFLAGS) -DENABLE_SLFUTURE_CONST $<
 $(OUTPUT)util/rbtree.o: ../../lib/rbtree.c $(OUTPUT)PERF-CFLAGS
 	$(QUIET_CC)$(CC) -o $@ -c $(ALL_CFLAGS) -DETC_PERFCONFIG='"$(ETC_PERFCONFIG_SQ)"' $<
 $(OUTPUT)util/scripting-engines/trace-event-perl.o: util/scripting-engines/trace-event-perl.c $(OUTPUT)PERF-CFLAGS
 	$(QUIET_CC)$(CC) -o $@ -c $(ALL_CFLAGS) $(PERL_EMBED_CCOPTS) -Wno-redundant-decls -Wno-strict-prototypes -Wno-unused-parameter -Wno-shadow $<
 $(OUTPUT)scripts/perl/Perf-Trace-Util/Context.o: scripts/perl/Perf-Trace-Util/Context.c $(OUTPUT)PERF-CFLAGS
 	$(QUIET_CC)$(CC) -o $@ -c $(ALL_CFLAGS) $(PERL_EMBED_CCOPTS) -Wno-redundant-decls -Wno-strict-prototypes -Wno-unused-parameter -Wno-nested-externs $<
 $(OUTPUT)util/scripting-engines/trace-event-python.o: util/scripting-engines/trace-event-python.c $(OUTPUT)PERF-CFLAGS
 	$(QUIET_CC)$(CC) -o $@ -c $(ALL_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 $(ALL_CFLAGS) $(PYTHON_EMBED_CCOPTS) -Wno-redundant-decls -Wno-strict-prototypes -Wno-unused-parameter -Wno-nested-externs $<
 $(OUTPUT)perf-%: %.o $(PERFLIBS)
 	$(QUIET_LINK)$(CC) $(ALL_CFLAGS) -o $@ $(ALL_LDFLAGS) $(filter %.o,$^) $(LIBS)
 $(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) $(OUTPUT)PERF-VERSION-FILE $(OUTPUT)common-cmds.h
 $(DIRECTORY_DEPS): | $(sort $(dir $(DIRECTORY_DEPS)))
 # In the second step, we make a rule to actually create these directories
 $(sort $(dir $(DIRECTORY_DEPS))):
 	$(QUIET_MKDIR)$(MKDIR) -p $@ 2>/dev/null
 $(LIB_FILE): $(LIB_OBJS)
 	$(QUIET_AR)$(RM) $@ && $(AR) rcs $@ $(LIB_OBJS)
 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 "make prefix=<path> <install target>" 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 '  distclean		- alias to clean'
 	@echo '  clean			- clean all binary objects and build output'
 doc:
 	$(MAKE) -C Documentation all
 man:
 	$(MAKE) -C Documentation man
 html:
 	$(MAKE) -C Documentation html
 info:
 	$(MAKE) -C Documentation info
 pdf:
 	$(MAKE) -C Documentation pdf
 TAGS:
 	$(RM) TAGS
 	$(FIND) . -name '*.[hcS]' -print | xargs etags -a
 tags:
 	$(RM) tags
 	$(FIND) . -name '*.[hcS]' -print | xargs ctags -a
 cscope:
 	$(RM) cscope*
 	$(FIND) . -name '*.[hcS]' -print | xargs cscope -b
 ### Detect prefix changes
 TRACK_CFLAGS = $(subst ','\'',$(ALL_CFLAGS)):\
              $(bindir_SQ):$(perfexecdir_SQ):$(template_dir_SQ):$(prefix_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 "    * 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 $(ALL_CFLAGS) $(SPARSE_FLAGS) $$i || exit; \
 		done; \
 	else \
 		exit 1; \
 	fi
 ### Installation rules
 ifneq ($(filter /%,$(firstword $(perfexecdir))),)
 perfexec_instdir = $(perfexecdir)
 else
 perfexec_instdir = $(prefix)/$(perfexecdir)
 endif
 perfexec_instdir_SQ = $(subst ','\'',$(perfexec_instdir))
 install: all
 	$(INSTALL) -d -m 755 '$(DESTDIR_SQ)$(bindir_SQ)'
 	$(INSTALL) $(OUTPUT)perf '$(DESTDIR_SQ)$(bindir_SQ)'
 	$(INSTALL) -d -m 755 '$(DESTDIR_SQ)$(perfexec_instdir_SQ)/scripts/perl/Perf-Trace-Util/lib/Perf/Trace'
 	$(INSTALL) -d -m 755 '$(DESTDIR_SQ)$(perfexec_instdir_SQ)/scripts/perl/bin'
 	$(INSTALL) $(OUTPUT)perf-archive -t '$(DESTDIR_SQ)$(perfexec_instdir_SQ)'
 	$(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) scripts/perl/bin/* -t '$(DESTDIR_SQ)$(perfexec_instdir_SQ)/scripts/perl/bin'
 	$(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'
+install-python_ext:
+	$(PYTHON_WORD) util/setup.py --quiet install --root='/$(DESTDIR_SQ)'
 install-doc:
 	$(MAKE) -C Documentation install
 install-man:
 	$(MAKE) -C Documentation install-man
 install-html:
 	$(MAKE) -C Documentation install-html
 install-info:
 	$(MAKE) -C Documentation install-info
 install-pdf:
 	$(MAKE) -C Documentation install-pdf
 quick-install-doc:
 	$(MAKE) -C Documentation quick-install
 quick-install-man:
 	$(MAKE) -C Documentation quick-install-man
 quick-install-html:
 	$(MAKE) -C Documentation quick-install-html
 ### Cleaning rules
 clean:
-	$(RM) $(OUTPUT){*.o,*/*.o,*/*/*.o,*/*/*/*.o,$(LIB_FILE),perf-archive}
+	$(RM) $(LIB_OBJS) $(BUILTIN_OBJS) $(LIB_FILE) $(OUTPUT)perf-archive $(OUTPUT)perf.o $(LANG_BINDINGS)
 	$(RM) $(ALL_PROGRAMS) perf
 	$(RM) *.spec *.pyc *.pyo */*.pyc */*.pyo $(OUTPUT)common-cmds.h TAGS tags cscope*
 	$(MAKE) -C Documentation/ clean
 	$(RM) $(OUTPUT)PERF-VERSION-FILE $(OUTPUT)PERF-CFLAGS
 	$(python-clean)
 .PHONY: all install clean strip
 .PHONY: shell_compatibility_test please_set_SHELL_PATH_to_a_more_modern_shell
 .PHONY: .FORCE-PERF-VERSION-FILE TAGS tags cscope .FORCE-PERF-CFLAGS

tools/perf/builtin-lock.c

Diff comments View file @ 1d229d5

1	#include "builtin.h"	1	#include "builtin.h"
2	#include "perf.h"	2	#include "perf.h"
3		3
4	#include "util/util.h"	4	#include "util/util.h"
5	#include "util/cache.h"	5	#include "util/cache.h"
6	#include "util/symbol.h"	6	#include "util/symbol.h"
7	#include "util/thread.h"	7	#include "util/thread.h"
8	#include "util/header.h"	8	#include "util/header.h"
9		9
10	#include "util/parse-options.h"	10	#include "util/parse-options.h"
11	#include "util/trace-event.h"	11	#include "util/trace-event.h"
12		12
13	#include "util/debug.h"	13	#include "util/debug.h"
14	#include "util/session.h"	14	#include "util/session.h"
15		15
16	#include <sys/types.h>	16	#include <sys/types.h>
17	#include <sys/prctl.h>	17	#include <sys/prctl.h>
18	#include <semaphore.h>	18	#include <semaphore.h>
19	#include <pthread.h>	19	#include <pthread.h>
20	#include <math.h>	20	#include <math.h>
21	#include <limits.h>	21	#include <limits.h>
22		22
23	#include <linux/list.h>	23	#include <linux/list.h>
24	#include <linux/hash.h>	24	#include <linux/hash.h>
25		25
26	static struct perf_session *session;	26	static struct perf_session *session;
27		27
28	/* based on kernel/lockdep.c */	28	/* based on kernel/lockdep.c */
29	#define LOCKHASH_BITS 12	29	#define LOCKHASH_BITS 12
30	#define LOCKHASH_SIZE (1UL << LOCKHASH_BITS)	30	#define LOCKHASH_SIZE (1UL << LOCKHASH_BITS)
31		31
32	static struct list_head lockhash_table[LOCKHASH_SIZE];	32	static struct list_head lockhash_table[LOCKHASH_SIZE];
33		33
34	#define __lockhashfn(key) hash_long((unsigned long)key, LOCKHASH_BITS)	34	#define __lockhashfn(key) hash_long((unsigned long)key, LOCKHASH_BITS)
35	#define lockhashentry(key) (lockhash_table + __lockhashfn((key)))	35	#define lockhashentry(key) (lockhash_table + __lockhashfn((key)))
36		36
37	struct lock_stat {	37	struct lock_stat {
38	struct list_head hash_entry;	38	struct list_head hash_entry;
39	struct rb_node rb; /* used for sorting */	39	struct rb_node rb; /* used for sorting */
40		40
41	/*	41	/*
42	* FIXME: raw_field_value() returns unsigned long long,	42	* FIXME: raw_field_value() returns unsigned long long,
43	* so address of lockdep_map should be dealed as 64bit.	43	* so address of lockdep_map should be dealed as 64bit.
44	* Is there more better solution?	44	* Is there more better solution?
45	*/	45	*/
46	void addr; / address of lockdep_map, used as ID */	46	void addr; / address of lockdep_map, used as ID */
47	char name; / for strcpy(), we cannot use const */	47	char name; / for strcpy(), we cannot use const */
48		48
49	unsigned int nr_acquire;	49	unsigned int nr_acquire;
50	unsigned int nr_acquired;	50	unsigned int nr_acquired;
51	unsigned int nr_contended;	51	unsigned int nr_contended;
52	unsigned int nr_release;	52	unsigned int nr_release;
53		53
54	unsigned int nr_readlock;	54	unsigned int nr_readlock;
55	unsigned int nr_trylock;	55	unsigned int nr_trylock;
56	/* these times are in nano sec. */	56	/* these times are in nano sec. */
57	u64 wait_time_total;	57	u64 wait_time_total;
58	u64 wait_time_min;	58	u64 wait_time_min;
59	u64 wait_time_max;	59	u64 wait_time_max;
60		60
61	int discard; /* flag of blacklist */	61	int discard; /* flag of blacklist */
62	};	62	};
63		63
64	/*	64	/*
65	* States of lock_seq_stat	65	* States of lock_seq_stat
66	*	66	*
67	* UNINITIALIZED is required for detecting first event of acquire.	67	* UNINITIALIZED is required for detecting first event of acquire.
68	* As the nature of lock events, there is no guarantee	68	* As the nature of lock events, there is no guarantee
69	* that the first event for the locks are acquire,	69	* that the first event for the locks are acquire,
70	* it can be acquired, contended or release.	70	* it can be acquired, contended or release.
71	*/	71	*/
72	#define SEQ_STATE_UNINITIALIZED 0 /* initial state */	72	#define SEQ_STATE_UNINITIALIZED 0 /* initial state */
73	#define SEQ_STATE_RELEASED 1	73	#define SEQ_STATE_RELEASED 1
74	#define SEQ_STATE_ACQUIRING 2	74	#define SEQ_STATE_ACQUIRING 2
75	#define SEQ_STATE_ACQUIRED 3	75	#define SEQ_STATE_ACQUIRED 3
76	#define SEQ_STATE_READ_ACQUIRED 4	76	#define SEQ_STATE_READ_ACQUIRED 4
77	#define SEQ_STATE_CONTENDED 5	77	#define SEQ_STATE_CONTENDED 5
78		78
79	/*	79	/*
80	* MAX_LOCK_DEPTH	80	* MAX_LOCK_DEPTH
81	* Imported from include/linux/sched.h.	81	* Imported from include/linux/sched.h.
82	* Should this be synchronized?	82	* Should this be synchronized?
83	*/	83	*/
84	#define MAX_LOCK_DEPTH 48	84	#define MAX_LOCK_DEPTH 48
85		85
86	/*	86	/*
87	* struct lock_seq_stat:	87	* struct lock_seq_stat:
88	* Place to put on state of one lock sequence	88	* Place to put on state of one lock sequence
89	* 1) acquire -> acquired -> release	89	* 1) acquire -> acquired -> release
90	* 2) acquire -> contended -> acquired -> release	90	* 2) acquire -> contended -> acquired -> release
91	* 3) acquire (with read or try) -> release	91	* 3) acquire (with read or try) -> release
92	* 4) Are there other patterns?	92	* 4) Are there other patterns?
93	*/	93	*/
94	struct lock_seq_stat {	94	struct lock_seq_stat {
95	struct list_head list;	95	struct list_head list;
96	int state;	96	int state;
97	u64 prev_event_time;	97	u64 prev_event_time;
98	void *addr;	98	void *addr;
99		99
100	int read_count;	100	int read_count;
101	};	101	};
102		102
103	struct thread_stat {	103	struct thread_stat {
104	struct rb_node rb;	104	struct rb_node rb;
105		105
106	u32 tid;	106	u32 tid;
107	struct list_head seq_list;	107	struct list_head seq_list;
108	};	108	};
109		109
110	static struct rb_root thread_stats;	110	static struct rb_root thread_stats;
111		111
112	static struct thread_stat *thread_stat_find(u32 tid)	112	static struct thread_stat *thread_stat_find(u32 tid)
113	{	113	{
114	struct rb_node *node;	114	struct rb_node *node;
115	struct thread_stat *st;	115	struct thread_stat *st;
116		116
117	node = thread_stats.rb_node;	117	node = thread_stats.rb_node;
118	while (node) {	118	while (node) {
119	st = container_of(node, struct thread_stat, rb);	119	st = container_of(node, struct thread_stat, rb);
120	if (st->tid == tid)	120	if (st->tid == tid)
121	return st;	121	return st;
122	else if (tid < st->tid)	122	else if (tid < st->tid)
123	node = node->rb_left;	123	node = node->rb_left;
124	else	124	else
125	node = node->rb_right;	125	node = node->rb_right;
126	}	126	}
127		127
128	return NULL;	128	return NULL;
129	}	129	}
130		130
131	static void thread_stat_insert(struct thread_stat *new)	131	static void thread_stat_insert(struct thread_stat *new)
132	{	132	{
133	struct rb_node **rb = &thread_stats.rb_node;	133	struct rb_node **rb = &thread_stats.rb_node;
134	struct rb_node *parent = NULL;	134	struct rb_node *parent = NULL;
135	struct thread_stat *p;	135	struct thread_stat *p;
136		136
137	while (*rb) {	137	while (*rb) {
138	p = container_of(*rb, struct thread_stat, rb);	138	p = container_of(*rb, struct thread_stat, rb);
139	parent = *rb;	139	parent = *rb;
140		140
141	if (new->tid < p->tid)	141	if (new->tid < p->tid)
142	rb = &(*rb)->rb_left;	142	rb = &(*rb)->rb_left;
143	else if (new->tid > p->tid)	143	else if (new->tid > p->tid)
144	rb = &(*rb)->rb_right;	144	rb = &(*rb)->rb_right;
145	else	145	else
146	BUG_ON("inserting invalid thread_stat\n");	146	BUG_ON("inserting invalid thread_stat\n");
147	}	147	}
148		148
149	rb_link_node(&new->rb, parent, rb);	149	rb_link_node(&new->rb, parent, rb);
150	rb_insert_color(&new->rb, &thread_stats);	150	rb_insert_color(&new->rb, &thread_stats);
151	}	151	}
152		152
153	static struct thread_stat *thread_stat_findnew_after_first(u32 tid)	153	static struct thread_stat *thread_stat_findnew_after_first(u32 tid)
154	{	154	{
155	struct thread_stat *st;	155	struct thread_stat *st;
156		156
157	st = thread_stat_find(tid);	157	st = thread_stat_find(tid);
158	if (st)	158	if (st)
159	return st;	159	return st;
160		160
161	st = zalloc(sizeof(struct thread_stat));	161	st = zalloc(sizeof(struct thread_stat));
162	if (!st)	162	if (!st)
163	die("memory allocation failed\n");	163	die("memory allocation failed\n");
164		164
165	st->tid = tid;	165	st->tid = tid;
166	INIT_LIST_HEAD(&st->seq_list);	166	INIT_LIST_HEAD(&st->seq_list);
167		167
168	thread_stat_insert(st);	168	thread_stat_insert(st);
169		169
170	return st;	170	return st;
171	}	171	}
172		172
173	static struct thread_stat *thread_stat_findnew_first(u32 tid);	173	static struct thread_stat *thread_stat_findnew_first(u32 tid);
174	static struct thread_stat (thread_stat_findnew)(u32 tid) =	174	static struct thread_stat (thread_stat_findnew)(u32 tid) =
175	thread_stat_findnew_first;	175	thread_stat_findnew_first;
176		176
177	static struct thread_stat *thread_stat_findnew_first(u32 tid)	177	static struct thread_stat *thread_stat_findnew_first(u32 tid)
178	{	178	{
179	struct thread_stat *st;	179	struct thread_stat *st;
180		180
181	st = zalloc(sizeof(struct thread_stat));	181	st = zalloc(sizeof(struct thread_stat));
182	if (!st)	182	if (!st)
183	die("memory allocation failed\n");	183	die("memory allocation failed\n");
184	st->tid = tid;	184	st->tid = tid;
185	INIT_LIST_HEAD(&st->seq_list);	185	INIT_LIST_HEAD(&st->seq_list);
186		186
187	rb_link_node(&st->rb, NULL, &thread_stats.rb_node);	187	rb_link_node(&st->rb, NULL, &thread_stats.rb_node);
188	rb_insert_color(&st->rb, &thread_stats);	188	rb_insert_color(&st->rb, &thread_stats);
189		189
190	thread_stat_findnew = thread_stat_findnew_after_first;	190	thread_stat_findnew = thread_stat_findnew_after_first;
191	return st;	191	return st;
192	}	192	}
193		193
194	/* build simple key function one is bigger than two */	194	/* build simple key function one is bigger than two */
195	#define SINGLE_KEY(member) \	195	#define SINGLE_KEY(member) \
196	static int lock_stat_key_ ## member(struct lock_stat *one, \	196	static int lock_stat_key_ ## member(struct lock_stat *one, \
197	struct lock_stat *two) \	197	struct lock_stat *two) \
198	{ \	198	{ \
199	return one->member > two->member; \	199	return one->member > two->member; \
200	}	200	}
201		201
202	SINGLE_KEY(nr_acquired)	202	SINGLE_KEY(nr_acquired)
203	SINGLE_KEY(nr_contended)	203	SINGLE_KEY(nr_contended)
204	SINGLE_KEY(wait_time_total)	204	SINGLE_KEY(wait_time_total)
205	SINGLE_KEY(wait_time_max)	205	SINGLE_KEY(wait_time_max)
206		206
207	static int lock_stat_key_wait_time_min(struct lock_stat *one,	207	static int lock_stat_key_wait_time_min(struct lock_stat *one,
208	struct lock_stat *two)	208	struct lock_stat *two)
209	{	209	{
210	u64 s1 = one->wait_time_min;	210	u64 s1 = one->wait_time_min;
211	u64 s2 = two->wait_time_min;	211	u64 s2 = two->wait_time_min;
212	if (s1 == ULLONG_MAX)	212	if (s1 == ULLONG_MAX)
213	s1 = 0;	213	s1 = 0;
214	if (s2 == ULLONG_MAX)	214	if (s2 == ULLONG_MAX)
215	s2 = 0;	215	s2 = 0;
216	return s1 > s2;	216	return s1 > s2;
217	}	217	}
218		218
219	struct lock_key {	219	struct lock_key {
220	/*	220	/*
221	* name: the value for specify by user	221	* name: the value for specify by user
222	* this should be simpler than raw name of member	222	* this should be simpler than raw name of member
223	* e.g. nr_acquired -> acquired, wait_time_total -> wait_total	223	* e.g. nr_acquired -> acquired, wait_time_total -> wait_total
224	*/	224	*/
225	const char *name;	225	const char *name;
226	int (key)(struct lock_stat, struct lock_stat*);	226	int (key)(struct lock_stat, struct lock_stat*);
227	};	227	};
228		228
229	static const char *sort_key = "acquired";	229	static const char *sort_key = "acquired";
230		230
231	static int (compare)(struct lock_stat , struct lock_stat *);	231	static int (compare)(struct lock_stat , struct lock_stat *);
232		232
233	static struct rb_root result; /* place to store sorted data */	233	static struct rb_root result; /* place to store sorted data */
234		234
235	#define DEF_KEY_LOCK(name, fn_suffix) \	235	#define DEF_KEY_LOCK(name, fn_suffix) \
236	{ #name, lock_stat_key_ ## fn_suffix }	236	{ #name, lock_stat_key_ ## fn_suffix }
237	struct lock_key keys[] = {	237	struct lock_key keys[] = {
238	DEF_KEY_LOCK(acquired, nr_acquired),	238	DEF_KEY_LOCK(acquired, nr_acquired),
239	DEF_KEY_LOCK(contended, nr_contended),	239	DEF_KEY_LOCK(contended, nr_contended),
240	DEF_KEY_LOCK(wait_total, wait_time_total),	240	DEF_KEY_LOCK(wait_total, wait_time_total),
241	DEF_KEY_LOCK(wait_min, wait_time_min),	241	DEF_KEY_LOCK(wait_min, wait_time_min),
242	DEF_KEY_LOCK(wait_max, wait_time_max),	242	DEF_KEY_LOCK(wait_max, wait_time_max),
243		243
244	/* extra comparisons much complicated should be here */	244	/* extra comparisons much complicated should be here */
245		245
246	{ NULL, NULL }	246	{ NULL, NULL }
247	};	247	};
248		248
249	static void select_key(void)	249	static void select_key(void)
250	{	250	{
251	int i;	251	int i;
252		252
253	for (i = 0; keys[i].name; i++) {	253	for (i = 0; keys[i].name; i++) {
254	if (!strcmp(keys[i].name, sort_key)) {	254	if (!strcmp(keys[i].name, sort_key)) {
255	compare = keys[i].key;	255	compare = keys[i].key;
256	return;	256	return;
257	}	257	}
258	}	258	}
259		259
260	die("Unknown compare key:%s\n", sort_key);	260	die("Unknown compare key:%s\n", sort_key);
261	}	261	}
262		262
263	static void insert_to_result(struct lock_stat *st,	263	static void insert_to_result(struct lock_stat *st,
264	int (bigger)(struct lock_stat , struct lock_stat *))	264	int (bigger)(struct lock_stat , struct lock_stat *))
265	{	265	{
266	struct rb_node **rb = &result.rb_node;	266	struct rb_node **rb = &result.rb_node;
267	struct rb_node *parent = NULL;	267	struct rb_node *parent = NULL;
268	struct lock_stat *p;	268	struct lock_stat *p;
269		269
270	while (*rb) {	270	while (*rb) {
271	p = container_of(*rb, struct lock_stat, rb);	271	p = container_of(*rb, struct lock_stat, rb);
272	parent = *rb;	272	parent = *rb;
273		273
274	if (bigger(st, p))	274	if (bigger(st, p))
275	rb = &(*rb)->rb_left;	275	rb = &(*rb)->rb_left;
276	else	276	else
277	rb = &(*rb)->rb_right;	277	rb = &(*rb)->rb_right;
278	}	278	}
279		279
280	rb_link_node(&st->rb, parent, rb);	280	rb_link_node(&st->rb, parent, rb);
281	rb_insert_color(&st->rb, &result);	281	rb_insert_color(&st->rb, &result);
282	}	282	}
283		283
284	/* returns left most element of result, and erase it */	284	/* returns left most element of result, and erase it */
285	static struct lock_stat *pop_from_result(void)	285	static struct lock_stat *pop_from_result(void)
286	{	286	{
287	struct rb_node *node = result.rb_node;	287	struct rb_node *node = result.rb_node;
288		288
289	if (!node)	289	if (!node)
290	return NULL;	290	return NULL;
291		291
292	while (node->rb_left)	292	while (node->rb_left)
293	node = node->rb_left;	293	node = node->rb_left;
294		294
295	rb_erase(node, &result);	295	rb_erase(node, &result);
296	return container_of(node, struct lock_stat, rb);	296	return container_of(node, struct lock_stat, rb);
297	}	297	}
298		298
299	static struct lock_stat lock_stat_findnew(void addr, const char *name)	299	static struct lock_stat lock_stat_findnew(void addr, const char *name)
300	{	300	{
301	struct list_head *entry = lockhashentry(addr);	301	struct list_head *entry = lockhashentry(addr);
302	struct lock_stat ret, new;	302	struct lock_stat ret, new;
303		303
304	list_for_each_entry(ret, entry, hash_entry) {	304	list_for_each_entry(ret, entry, hash_entry) {
305	if (ret->addr == addr)	305	if (ret->addr == addr)
306	return ret;	306	return ret;
307	}	307	}
308		308
309	new = zalloc(sizeof(struct lock_stat));	309	new = zalloc(sizeof(struct lock_stat));
310	if (!new)	310	if (!new)
311	goto alloc_failed;	311	goto alloc_failed;
312		312
313	new->addr = addr;	313	new->addr = addr;
314	new->name = zalloc(sizeof(char) * strlen(name) + 1);	314	new->name = zalloc(sizeof(char) * strlen(name) + 1);
315	if (!new->name)	315	if (!new->name)
316	goto alloc_failed;	316	goto alloc_failed;
317	strcpy(new->name, name);	317	strcpy(new->name, name);
318		318
319	new->wait_time_min = ULLONG_MAX;	319	new->wait_time_min = ULLONG_MAX;
320		320
321	list_add(&new->hash_entry, entry);	321	list_add(&new->hash_entry, entry);
322	return new;	322	return new;
323		323
324	alloc_failed:	324	alloc_failed:
325	die("memory allocation failed\n");	325	die("memory allocation failed\n");
326	}	326	}
327		327
328	static char const *input_name = "perf.data";	328	static char const *input_name = "perf.data";
329		329
330	struct raw_event_sample {	330	struct raw_event_sample {
331	u32 size;	331	u32 size;
332	char data[0];	332	char data[0];
333	};	333	};
334		334
335	struct trace_acquire_event {	335	struct trace_acquire_event {
336	void *addr;	336	void *addr;
337	const char *name;	337	const char *name;
338	int flag;	338	int flag;
339	};	339	};
340		340
341	struct trace_acquired_event {	341	struct trace_acquired_event {
342	void *addr;	342	void *addr;
343	const char *name;	343	const char *name;
344	};	344	};
345		345
346	struct trace_contended_event {	346	struct trace_contended_event {
347	void *addr;	347	void *addr;
348	const char *name;	348	const char *name;
349	};	349	};
350		350
351	struct trace_release_event {	351	struct trace_release_event {
352	void *addr;	352	void *addr;
353	const char *name;	353	const char *name;
354	};	354	};
355		355
356	struct trace_lock_handler {	356	struct trace_lock_handler {
357	void (acquire_event)(struct trace_acquire_event ,	357	void (acquire_event)(struct trace_acquire_event ,
358	struct event *,	358	struct event *,
359	int cpu,	359	int cpu,
360	u64 timestamp,	360	u64 timestamp,
361	struct thread *thread);	361	struct thread *thread);
362		362
363	void (acquired_event)(struct trace_acquired_event ,	363	void (acquired_event)(struct trace_acquired_event ,
364	struct event *,	364	struct event *,
365	int cpu,	365	int cpu,
366	u64 timestamp,	366	u64 timestamp,
367	struct thread *thread);	367	struct thread *thread);
368		368
369	void (contended_event)(struct trace_contended_event ,	369	void (contended_event)(struct trace_contended_event ,
370	struct event *,	370	struct event *,
371	int cpu,	371	int cpu,
372	u64 timestamp,	372	u64 timestamp,
373	struct thread *thread);	373	struct thread *thread);
374		374
375	void (release_event)(struct trace_release_event ,	375	void (release_event)(struct trace_release_event ,
376	struct event *,	376	struct event *,
377	int cpu,	377	int cpu,
378	u64 timestamp,	378	u64 timestamp,
379	struct thread *thread);	379	struct thread *thread);
380	};	380	};
381		381
382	static struct lock_seq_stat get_seq(struct thread_stat ts, void *addr)	382	static struct lock_seq_stat get_seq(struct thread_stat ts, void *addr)
383	{	383	{
384	struct lock_seq_stat *seq;	384	struct lock_seq_stat *seq;
385		385
386	list_for_each_entry(seq, &ts->seq_list, list) {	386	list_for_each_entry(seq, &ts->seq_list, list) {
387	if (seq->addr == addr)	387	if (seq->addr == addr)
388	return seq;	388	return seq;
389	}	389	}
390		390
391	seq = zalloc(sizeof(struct lock_seq_stat));	391	seq = zalloc(sizeof(struct lock_seq_stat));
392	if (!seq)	392	if (!seq)
393	die("Not enough memory\n");	393	die("Not enough memory\n");
394	seq->state = SEQ_STATE_UNINITIALIZED;	394	seq->state = SEQ_STATE_UNINITIALIZED;
395	seq->addr = addr;	395	seq->addr = addr;
396		396
397	list_add(&seq->list, &ts->seq_list);	397	list_add(&seq->list, &ts->seq_list);
398	return seq;	398	return seq;
399	}	399	}
400		400
401	enum broken_state {	401	enum broken_state {
402	BROKEN_ACQUIRE,	402	BROKEN_ACQUIRE,
403	BROKEN_ACQUIRED,	403	BROKEN_ACQUIRED,
404	BROKEN_CONTENDED,	404	BROKEN_CONTENDED,
405	BROKEN_RELEASE,	405	BROKEN_RELEASE,
406	BROKEN_MAX,	406	BROKEN_MAX,
407	};	407	};
408		408
409	static int bad_hist[BROKEN_MAX];	409	static int bad_hist[BROKEN_MAX];
410		410
411	enum acquire_flags {	411	enum acquire_flags {
412	TRY_LOCK = 1,	412	TRY_LOCK = 1,
413	READ_LOCK = 2,	413	READ_LOCK = 2,
414	};	414	};
415		415
416	static void	416	static void
417	report_lock_acquire_event(struct trace_acquire_event *acquire_event,	417	report_lock_acquire_event(struct trace_acquire_event *acquire_event,
418	struct event *__event __used,	418	struct event *__event __used,
419	int cpu __used,	419	int cpu __used,
420	u64 timestamp __used,	420	u64 timestamp __used,
421	struct thread *thread __used)	421	struct thread *thread __used)
422	{	422	{
423	struct lock_stat *ls;	423	struct lock_stat *ls;
424	struct thread_stat *ts;	424	struct thread_stat *ts;
425	struct lock_seq_stat *seq;	425	struct lock_seq_stat *seq;
426		426
427	ls = lock_stat_findnew(acquire_event->addr, acquire_event->name);	427	ls = lock_stat_findnew(acquire_event->addr, acquire_event->name);
428	if (ls->discard)	428	if (ls->discard)
429	return;	429	return;
430		430
431	ts = thread_stat_findnew(thread->pid);	431	ts = thread_stat_findnew(thread->pid);
432	seq = get_seq(ts, acquire_event->addr);	432	seq = get_seq(ts, acquire_event->addr);
433		433
434	switch (seq->state) {	434	switch (seq->state) {
435	case SEQ_STATE_UNINITIALIZED:	435	case SEQ_STATE_UNINITIALIZED:
436	case SEQ_STATE_RELEASED:	436	case SEQ_STATE_RELEASED:
437	if (!acquire_event->flag) {	437	if (!acquire_event->flag) {
438	seq->state = SEQ_STATE_ACQUIRING;	438	seq->state = SEQ_STATE_ACQUIRING;
439	} else {	439	} else {
440	if (acquire_event->flag & TRY_LOCK)	440	if (acquire_event->flag & TRY_LOCK)
441	ls->nr_trylock++;	441	ls->nr_trylock++;
442	if (acquire_event->flag & READ_LOCK)	442	if (acquire_event->flag & READ_LOCK)
443	ls->nr_readlock++;	443	ls->nr_readlock++;
444	seq->state = SEQ_STATE_READ_ACQUIRED;	444	seq->state = SEQ_STATE_READ_ACQUIRED;
445	seq->read_count = 1;	445	seq->read_count = 1;
446	ls->nr_acquired++;	446	ls->nr_acquired++;
447	}	447	}
448	break;	448	break;
449	case SEQ_STATE_READ_ACQUIRED:	449	case SEQ_STATE_READ_ACQUIRED:
450	if (acquire_event->flag & READ_LOCK) {	450	if (acquire_event->flag & READ_LOCK) {
451	seq->read_count++;	451	seq->read_count++;
452	ls->nr_acquired++;	452	ls->nr_acquired++;
453	goto end;	453	goto end;
454	} else {	454	} else {
455	goto broken;	455	goto broken;
456	}	456	}
457	break;	457	break;
458	case SEQ_STATE_ACQUIRED:	458	case SEQ_STATE_ACQUIRED:
459	case SEQ_STATE_ACQUIRING:	459	case SEQ_STATE_ACQUIRING:
460	case SEQ_STATE_CONTENDED:	460	case SEQ_STATE_CONTENDED:
461	broken:	461	broken:
462	/* broken lock sequence, discard it */	462	/* broken lock sequence, discard it */
463	ls->discard = 1;	463	ls->discard = 1;
464	bad_hist[BROKEN_ACQUIRE]++;	464	bad_hist[BROKEN_ACQUIRE]++;
465	list_del(&seq->list);	465	list_del(&seq->list);
466	free(seq);	466	free(seq);
467	goto end;	467	goto end;
468	break;	468	break;
469	default:	469	default:
470	BUG_ON("Unknown state of lock sequence found!\n");	470	BUG_ON("Unknown state of lock sequence found!\n");
471	break;	471	break;
472	}	472	}
473		473
474	ls->nr_acquire++;	474	ls->nr_acquire++;
475	seq->prev_event_time = timestamp;	475	seq->prev_event_time = timestamp;
476	end:	476	end:
477	return;	477	return;
478	}	478	}
479		479
480	static void	480	static void
481	report_lock_acquired_event(struct trace_acquired_event *acquired_event,	481	report_lock_acquired_event(struct trace_acquired_event *acquired_event,
482	struct event *__event __used,	482	struct event *__event __used,
483	int cpu __used,	483	int cpu __used,
484	u64 timestamp __used,	484	u64 timestamp __used,
485	struct thread *thread __used)	485	struct thread *thread __used)
486	{	486	{
487	struct lock_stat *ls;	487	struct lock_stat *ls;
488	struct thread_stat *ts;	488	struct thread_stat *ts;
489	struct lock_seq_stat *seq;	489	struct lock_seq_stat *seq;
490	u64 contended_term;	490	u64 contended_term;
491		491
492	ls = lock_stat_findnew(acquired_event->addr, acquired_event->name);	492	ls = lock_stat_findnew(acquired_event->addr, acquired_event->name);
493	if (ls->discard)	493	if (ls->discard)
494	return;	494	return;
495		495
496	ts = thread_stat_findnew(thread->pid);	496	ts = thread_stat_findnew(thread->pid);
497	seq = get_seq(ts, acquired_event->addr);	497	seq = get_seq(ts, acquired_event->addr);
498		498
499	switch (seq->state) {	499	switch (seq->state) {
500	case SEQ_STATE_UNINITIALIZED:	500	case SEQ_STATE_UNINITIALIZED:
501	/* orphan event, do nothing */	501	/* orphan event, do nothing */
502	return;	502	return;
503	case SEQ_STATE_ACQUIRING:	503	case SEQ_STATE_ACQUIRING:
504	break;	504	break;
505	case SEQ_STATE_CONTENDED:	505	case SEQ_STATE_CONTENDED:
506	contended_term = timestamp - seq->prev_event_time;	506	contended_term = timestamp - seq->prev_event_time;
507	ls->wait_time_total += contended_term;	507	ls->wait_time_total += contended_term;
508	if (contended_term < ls->wait_time_min)	508	if (contended_term < ls->wait_time_min)
509	ls->wait_time_min = contended_term;	509	ls->wait_time_min = contended_term;
510	if (ls->wait_time_max < contended_term)	510	if (ls->wait_time_max < contended_term)
511	ls->wait_time_max = contended_term;	511	ls->wait_time_max = contended_term;
512	break;	512	break;
513	case SEQ_STATE_RELEASED:	513	case SEQ_STATE_RELEASED:
514	case SEQ_STATE_ACQUIRED:	514	case SEQ_STATE_ACQUIRED:
515	case SEQ_STATE_READ_ACQUIRED:	515	case SEQ_STATE_READ_ACQUIRED:
516	/* broken lock sequence, discard it */	516	/* broken lock sequence, discard it */
517	ls->discard = 1;	517	ls->discard = 1;
518	bad_hist[BROKEN_ACQUIRED]++;	518	bad_hist[BROKEN_ACQUIRED]++;
519	list_del(&seq->list);	519	list_del(&seq->list);
520	free(seq);	520	free(seq);
521	goto end;	521	goto end;
522	break;	522	break;
523		523
524	default:	524	default:
525	BUG_ON("Unknown state of lock sequence found!\n");	525	BUG_ON("Unknown state of lock sequence found!\n");
526	break;	526	break;
527	}	527	}
528		528
529	seq->state = SEQ_STATE_ACQUIRED;	529	seq->state = SEQ_STATE_ACQUIRED;
530	ls->nr_acquired++;	530	ls->nr_acquired++;
531	seq->prev_event_time = timestamp;	531	seq->prev_event_time = timestamp;
532	end:	532	end:
533	return;	533	return;
534	}	534	}
535		535
536	static void	536	static void
537	report_lock_contended_event(struct trace_contended_event *contended_event,	537	report_lock_contended_event(struct trace_contended_event *contended_event,
538	struct event *__event __used,	538	struct event *__event __used,
539	int cpu __used,	539	int cpu __used,
540	u64 timestamp __used,	540	u64 timestamp __used,
541	struct thread *thread __used)	541	struct thread *thread __used)
542	{	542	{
543	struct lock_stat *ls;	543	struct lock_stat *ls;
544	struct thread_stat *ts;	544	struct thread_stat *ts;
545	struct lock_seq_stat *seq;	545	struct lock_seq_stat *seq;
546		546
547	ls = lock_stat_findnew(contended_event->addr, contended_event->name);	547	ls = lock_stat_findnew(contended_event->addr, contended_event->name);
548	if (ls->discard)	548	if (ls->discard)
549	return;	549	return;
550		550
551	ts = thread_stat_findnew(thread->pid);	551	ts = thread_stat_findnew(thread->pid);
552	seq = get_seq(ts, contended_event->addr);	552	seq = get_seq(ts, contended_event->addr);
553		553
554	switch (seq->state) {	554	switch (seq->state) {
555	case SEQ_STATE_UNINITIALIZED:	555	case SEQ_STATE_UNINITIALIZED:
556	/* orphan event, do nothing */	556	/* orphan event, do nothing */
557	return;	557	return;
558	case SEQ_STATE_ACQUIRING:	558	case SEQ_STATE_ACQUIRING:
559	break;	559	break;
560	case SEQ_STATE_RELEASED:	560	case SEQ_STATE_RELEASED:
561	case SEQ_STATE_ACQUIRED:	561	case SEQ_STATE_ACQUIRED:
562	case SEQ_STATE_READ_ACQUIRED:	562	case SEQ_STATE_READ_ACQUIRED:
563	case SEQ_STATE_CONTENDED:	563	case SEQ_STATE_CONTENDED:
564	/* broken lock sequence, discard it */	564	/* broken lock sequence, discard it */
565	ls->discard = 1;	565	ls->discard = 1;
566	bad_hist[BROKEN_CONTENDED]++;	566	bad_hist[BROKEN_CONTENDED]++;
567	list_del(&seq->list);	567	list_del(&seq->list);
568	free(seq);	568	free(seq);
569	goto end;	569	goto end;
570	break;	570	break;
571	default:	571	default:
572	BUG_ON("Unknown state of lock sequence found!\n");	572	BUG_ON("Unknown state of lock sequence found!\n");
573	break;	573	break;
574	}	574	}
575		575
576	seq->state = SEQ_STATE_CONTENDED;	576	seq->state = SEQ_STATE_CONTENDED;
577	ls->nr_contended++;	577	ls->nr_contended++;
578	seq->prev_event_time = timestamp;	578	seq->prev_event_time = timestamp;
579	end:	579	end:
580	return;	580	return;
581	}	581	}
582		582
583	static void	583	static void
584	report_lock_release_event(struct trace_release_event *release_event,	584	report_lock_release_event(struct trace_release_event *release_event,
585	struct event *__event __used,	585	struct event *__event __used,
586	int cpu __used,	586	int cpu __used,
587	u64 timestamp __used,	587	u64 timestamp __used,
588	struct thread *thread __used)	588	struct thread *thread __used)
589	{	589	{
590	struct lock_stat *ls;	590	struct lock_stat *ls;
591	struct thread_stat *ts;	591	struct thread_stat *ts;
592	struct lock_seq_stat *seq;	592	struct lock_seq_stat *seq;
593		593
594	ls = lock_stat_findnew(release_event->addr, release_event->name);	594	ls = lock_stat_findnew(release_event->addr, release_event->name);
595	if (ls->discard)	595	if (ls->discard)
596	return;	596	return;
597		597
598	ts = thread_stat_findnew(thread->pid);	598	ts = thread_stat_findnew(thread->pid);
599	seq = get_seq(ts, release_event->addr);	599	seq = get_seq(ts, release_event->addr);
600		600
601	switch (seq->state) {	601	switch (seq->state) {
602	case SEQ_STATE_UNINITIALIZED:	602	case SEQ_STATE_UNINITIALIZED:
603	goto end;	603	goto end;
604	break;	604	break;
605	case SEQ_STATE_ACQUIRED:	605	case SEQ_STATE_ACQUIRED:
606	break;	606	break;
607	case SEQ_STATE_READ_ACQUIRED:	607	case SEQ_STATE_READ_ACQUIRED:
608	seq->read_count--;	608	seq->read_count--;
609	BUG_ON(seq->read_count < 0);	609	BUG_ON(seq->read_count < 0);
610	if (!seq->read_count) {	610	if (!seq->read_count) {
611	ls->nr_release++;	611	ls->nr_release++;
612	goto end;	612	goto end;
613	}	613	}
614	break;	614	break;
615	case SEQ_STATE_ACQUIRING:	615	case SEQ_STATE_ACQUIRING:
616	case SEQ_STATE_CONTENDED:	616	case SEQ_STATE_CONTENDED:
617	case SEQ_STATE_RELEASED:	617	case SEQ_STATE_RELEASED:
618	/* broken lock sequence, discard it */	618	/* broken lock sequence, discard it */
619	ls->discard = 1;	619	ls->discard = 1;
620	bad_hist[BROKEN_RELEASE]++;	620	bad_hist[BROKEN_RELEASE]++;
621	goto free_seq;	621	goto free_seq;
622	break;	622	break;
623	default:	623	default:
624	BUG_ON("Unknown state of lock sequence found!\n");	624	BUG_ON("Unknown state of lock sequence found!\n");
625	break;	625	break;
626	}	626	}
627		627
628	ls->nr_release++;	628	ls->nr_release++;
629	free_seq:	629	free_seq:
630	list_del(&seq->list);	630	list_del(&seq->list);
631	free(seq);	631	free(seq);
632	end:	632	end:
633	return;	633	return;
634	}	634	}
635		635
636	/* lock oriented handlers */	636	/* lock oriented handlers */
637	/* TODO: handlers for CPU oriented, thread oriented */	637	/* TODO: handlers for CPU oriented, thread oriented */
638	static struct trace_lock_handler report_lock_ops = {	638	static struct trace_lock_handler report_lock_ops = {
639	.acquire_event = report_lock_acquire_event,	639	.acquire_event = report_lock_acquire_event,
640	.acquired_event = report_lock_acquired_event,	640	.acquired_event = report_lock_acquired_event,
641	.contended_event = report_lock_contended_event,	641	.contended_event = report_lock_contended_event,
642	.release_event = report_lock_release_event,	642	.release_event = report_lock_release_event,
643	};	643	};
644		644
645	static struct trace_lock_handler *trace_handler;	645	static struct trace_lock_handler *trace_handler;
646		646
647	static void	647	static void
648	process_lock_acquire_event(void *data,	648	process_lock_acquire_event(void *data,
649	struct event *event __used,	649	struct event *event __used,
650	int cpu __used,	650	int cpu __used,
651	u64 timestamp __used,	651	u64 timestamp __used,
652	struct thread *thread __used)	652	struct thread *thread __used)
653	{	653	{
654	struct trace_acquire_event acquire_event;	654	struct trace_acquire_event acquire_event;
655	u64 tmp; /* this is required for casting... */	655	u64 tmp; /* this is required for casting... */
656		656
657	tmp = raw_field_value(event, "lockdep_addr", data);	657	tmp = raw_field_value(event, "lockdep_addr", data);
658	memcpy(&acquire_event.addr, &tmp, sizeof(void *));	658	memcpy(&acquire_event.addr, &tmp, sizeof(void *));
659	acquire_event.name = (char *)raw_field_ptr(event, "name", data);	659	acquire_event.name = (char *)raw_field_ptr(event, "name", data);
660	acquire_event.flag = (int)raw_field_value(event, "flag", data);	660	acquire_event.flag = (int)raw_field_value(event, "flag", data);
661		661
662	if (trace_handler->acquire_event)	662	if (trace_handler->acquire_event)
663	trace_handler->acquire_event(&acquire_event, event, cpu, timestamp, thread);	663	trace_handler->acquire_event(&acquire_event, event, cpu, timestamp, thread);
664	}	664	}
665		665
666	static void	666	static void
667	process_lock_acquired_event(void *data,	667	process_lock_acquired_event(void *data,
668	struct event *event __used,	668	struct event *event __used,
669	int cpu __used,	669	int cpu __used,
670	u64 timestamp __used,	670	u64 timestamp __used,
671	struct thread *thread __used)	671	struct thread *thread __used)
672	{	672	{
673	struct trace_acquired_event acquired_event;	673	struct trace_acquired_event acquired_event;
674	u64 tmp; /* this is required for casting... */	674	u64 tmp; /* this is required for casting... */
675		675
676	tmp = raw_field_value(event, "lockdep_addr", data);	676	tmp = raw_field_value(event, "lockdep_addr", data);
677	memcpy(&acquired_event.addr, &tmp, sizeof(void *));	677	memcpy(&acquired_event.addr, &tmp, sizeof(void *));
678	acquired_event.name = (char *)raw_field_ptr(event, "name", data);	678	acquired_event.name = (char *)raw_field_ptr(event, "name", data);
679		679
680	if (trace_handler->acquire_event)	680	if (trace_handler->acquire_event)
681	trace_handler->acquired_event(&acquired_event, event, cpu, timestamp, thread);	681	trace_handler->acquired_event(&acquired_event, event, cpu, timestamp, thread);
682	}	682	}
683		683
684	static void	684	static void
685	process_lock_contended_event(void *data,	685	process_lock_contended_event(void *data,
686	struct event *event __used,	686	struct event *event __used,
687	int cpu __used,	687	int cpu __used,
688	u64 timestamp __used,	688	u64 timestamp __used,
689	struct thread *thread __used)	689	struct thread *thread __used)
690	{	690	{
691	struct trace_contended_event contended_event;	691	struct trace_contended_event contended_event;
692	u64 tmp; /* this is required for casting... */	692	u64 tmp; /* this is required for casting... */
693		693
694	tmp = raw_field_value(event, "lockdep_addr", data);	694	tmp = raw_field_value(event, "lockdep_addr", data);
695	memcpy(&contended_event.addr, &tmp, sizeof(void *));	695	memcpy(&contended_event.addr, &tmp, sizeof(void *));
696	contended_event.name = (char *)raw_field_ptr(event, "name", data);	696	contended_event.name = (char *)raw_field_ptr(event, "name", data);
697		697
698	if (trace_handler->acquire_event)	698	if (trace_handler->acquire_event)
699	trace_handler->contended_event(&contended_event, event, cpu, timestamp, thread);	699	trace_handler->contended_event(&contended_event, event, cpu, timestamp, thread);
700	}	700	}
701		701
702	static void	702	static void
703	process_lock_release_event(void *data,	703	process_lock_release_event(void *data,
704	struct event *event __used,	704	struct event *event __used,
705	int cpu __used,	705	int cpu __used,
706	u64 timestamp __used,	706	u64 timestamp __used,
707	struct thread *thread __used)	707	struct thread *thread __used)
708	{	708	{
709	struct trace_release_event release_event;	709	struct trace_release_event release_event;
710	u64 tmp; /* this is required for casting... */	710	u64 tmp; /* this is required for casting... */
711		711
712	tmp = raw_field_value(event, "lockdep_addr", data);	712	tmp = raw_field_value(event, "lockdep_addr", data);
713	memcpy(&release_event.addr, &tmp, sizeof(void *));	713	memcpy(&release_event.addr, &tmp, sizeof(void *));
714	release_event.name = (char *)raw_field_ptr(event, "name", data);	714	release_event.name = (char *)raw_field_ptr(event, "name", data);
715		715
716	if (trace_handler->acquire_event)	716	if (trace_handler->acquire_event)
717	trace_handler->release_event(&release_event, event, cpu, timestamp, thread);	717	trace_handler->release_event(&release_event, event, cpu, timestamp, thread);
718	}	718	}
719		719
720	static void	720	static void
721	process_raw_event(void data, int cpu, u64 timestamp, struct thread thread)	721	process_raw_event(void data, int cpu, u64 timestamp, struct thread thread)
722	{	722	{
723	struct event *event;	723	struct event *event;
724	int type;	724	int type;
725		725
726	type = trace_parse_common_type(data);	726	type = trace_parse_common_type(data);
727	event = trace_find_event(type);	727	event = trace_find_event(type);
728		728
729	if (!strcmp(event->name, "lock_acquire"))	729	if (!strcmp(event->name, "lock_acquire"))
730	process_lock_acquire_event(data, event, cpu, timestamp, thread);	730	process_lock_acquire_event(data, event, cpu, timestamp, thread);
731	if (!strcmp(event->name, "lock_acquired"))	731	if (!strcmp(event->name, "lock_acquired"))
732	process_lock_acquired_event(data, event, cpu, timestamp, thread);	732	process_lock_acquired_event(data, event, cpu, timestamp, thread);
733	if (!strcmp(event->name, "lock_contended"))	733	if (!strcmp(event->name, "lock_contended"))
734	process_lock_contended_event(data, event, cpu, timestamp, thread);	734	process_lock_contended_event(data, event, cpu, timestamp, thread);
735	if (!strcmp(event->name, "lock_release"))	735	if (!strcmp(event->name, "lock_release"))
736	process_lock_release_event(data, event, cpu, timestamp, thread);	736	process_lock_release_event(data, event, cpu, timestamp, thread);
737	}	737	}
738		738
739	static void print_bad_events(int bad, int total)	739	static void print_bad_events(int bad, int total)
740	{	740	{
741	/* Output for debug, this have to be removed */	741	/* Output for debug, this have to be removed */
742	int i;	742	int i;
743	const char *name[4] =	743	const char *name[4] =
744	{ "acquire", "acquired", "contended", "release" };	744	{ "acquire", "acquired", "contended", "release" };
745		745
746	pr_info("\n=== output for debug===\n\n");	746	pr_info("\n=== output for debug===\n\n");
747	pr_info("bad: %d, total: %d\n", bad, total);	747	pr_info("bad: %d, total: %d\n", bad, total);
748	pr_info("bad rate: %f %%\n", (double)bad / (double)total * 100);	748	pr_info("bad rate: %f %%\n", (double)bad / (double)total * 100);
749	pr_info("histogram of events caused bad sequence\n");	749	pr_info("histogram of events caused bad sequence\n");
750	for (i = 0; i < BROKEN_MAX; i++)	750	for (i = 0; i < BROKEN_MAX; i++)
751	pr_info(" %10s: %d\n", name[i], bad_hist[i]);	751	pr_info(" %10s: %d\n", name[i], bad_hist[i]);
752	}	752	}
753		753
754	/* TODO: various way to print, coloring, nano or milli sec */	754	/* TODO: various way to print, coloring, nano or milli sec */
755	static void print_result(void)	755	static void print_result(void)
756	{	756	{
757	struct lock_stat *st;	757	struct lock_stat *st;
758	char cut_name[20];	758	char cut_name[20];
759	int bad, total;	759	int bad, total;
760		760
761	pr_info("%20s ", "Name");	761	pr_info("%20s ", "Name");
762	pr_info("%10s ", "acquired");	762	pr_info("%10s ", "acquired");
763	pr_info("%10s ", "contended");	763	pr_info("%10s ", "contended");
764		764
765	pr_info("%15s ", "total wait (ns)");	765	pr_info("%15s ", "total wait (ns)");
766	pr_info("%15s ", "max wait (ns)");	766	pr_info("%15s ", "max wait (ns)");
767	pr_info("%15s ", "min wait (ns)");	767	pr_info("%15s ", "min wait (ns)");
768		768
769	pr_info("\n\n");	769	pr_info("\n\n");
770		770
771	bad = total = 0;	771	bad = total = 0;
772	while ((st = pop_from_result())) {	772	while ((st = pop_from_result())) {
773	total++;	773	total++;
774	if (st->discard) {	774	if (st->discard) {
775	bad++;	775	bad++;
776	continue;	776	continue;
777	}	777	}
778	bzero(cut_name, 20);	778	bzero(cut_name, 20);
779		779
780	if (strlen(st->name) < 16) {	780	if (strlen(st->name) < 16) {
781	/* output raw name */	781	/* output raw name */
782	pr_info("%20s ", st->name);	782	pr_info("%20s ", st->name);
783	} else {	783	} else {
784	strncpy(cut_name, st->name, 16);	784	strncpy(cut_name, st->name, 16);
785	cut_name[16] = '.';	785	cut_name[16] = '.';
786	cut_name[17] = '.';	786	cut_name[17] = '.';
787	cut_name[18] = '.';	787	cut_name[18] = '.';
788	cut_name[19] = '\0';	788	cut_name[19] = '\0';
789	/* cut off name for saving output style */	789	/* cut off name for saving output style */
790	pr_info("%20s ", cut_name);	790	pr_info("%20s ", cut_name);
791	}	791	}
792		792
793	pr_info("%10u ", st->nr_acquired);	793	pr_info("%10u ", st->nr_acquired);
794	pr_info("%10u ", st->nr_contended);	794	pr_info("%10u ", st->nr_contended);
795		795
796	pr_info("%15" PRIu64 " ", st->wait_time_total);	796	pr_info("%15" PRIu64 " ", st->wait_time_total);
797	pr_info("%15" PRIu64 " ", st->wait_time_max);	797	pr_info("%15" PRIu64 " ", st->wait_time_max);
798	pr_info("%15" PRIu64 " ", st->wait_time_min == ULLONG_MAX ?	798	pr_info("%15" PRIu64 " ", st->wait_time_min == ULLONG_MAX ?
799	0 : st->wait_time_min);	799	0 : st->wait_time_min);
800	pr_info("\n");	800	pr_info("\n");
801	}	801	}
802		802
803	print_bad_events(bad, total);	803	print_bad_events(bad, total);
804	}	804	}
805		805
806	static bool info_threads, info_map;	806	static bool info_threads, info_map;
807		807
808	static void dump_threads(void)	808	static void dump_threads(void)
809	{	809	{
810	struct thread_stat *st;	810	struct thread_stat *st;
811	struct rb_node *node;	811	struct rb_node *node;
812	struct thread *t;	812	struct thread *t;
813		813
814	pr_info("%10s: comm\n", "Thread ID");	814	pr_info("%10s: comm\n", "Thread ID");
815		815
816	node = rb_first(&thread_stats);	816	node = rb_first(&thread_stats);
817	while (node) {	817	while (node) {
818	st = container_of(node, struct thread_stat, rb);	818	st = container_of(node, struct thread_stat, rb);
819	t = perf_session__findnew(session, st->tid);	819	t = perf_session__findnew(session, st->tid);
820	pr_info("%10d: %s\n", st->tid, t->comm);	820	pr_info("%10d: %s\n", st->tid, t->comm);
821	node = rb_next(node);	821	node = rb_next(node);
822	};	822	};
823	}	823	}
824		824
825	static void dump_map(void)	825	static void dump_map(void)
826	{	826	{
827	unsigned int i;	827	unsigned int i;
828	struct lock_stat *st;	828	struct lock_stat *st;
829		829
830	pr_info("Address of instance: name of class\n");	830	pr_info("Address of instance: name of class\n");
831	for (i = 0; i < LOCKHASH_SIZE; i++) {	831	for (i = 0; i < LOCKHASH_SIZE; i++) {
832	list_for_each_entry(st, &lockhash_table[i], hash_entry) {	832	list_for_each_entry(st, &lockhash_table[i], hash_entry) {
833	pr_info(" %p: %s\n", st->addr, st->name);	833	pr_info(" %p: %s\n", st->addr, st->name);
834	}	834	}
835	}	835	}
836	}	836	}
837		837
838	static void dump_info(void)	838	static void dump_info(void)
839	{	839	{
840	if (info_threads)	840	if (info_threads)
841	dump_threads();	841	dump_threads();
842	else if (info_map)	842	else if (info_map)
843	dump_map();	843	dump_map();
844	else	844	else
845	die("Unknown type of information\n");	845	die("Unknown type of information\n");
846	}	846	}
847		847
848	static int process_sample_event(union perf_event *event,	848	static int process_sample_event(union perf_event *event,
849	struct perf_sample *sample,	849	struct perf_sample *sample,
850	struct perf_evsel *evsel __used,	850	struct perf_evsel *evsel __used,
851	struct perf_session *s)	851	struct perf_session *s)
852	{	852	{
853	struct thread *thread = perf_session__findnew(s, sample->tid);	853	struct thread *thread = perf_session__findnew(s, sample->tid);
854		854
855	if (thread == NULL) {	855	if (thread == NULL) {
856	pr_debug("problem processing %d event, skipping it.\n",	856	pr_debug("problem processing %d event, skipping it.\n",
857	event->header.type);	857	event->header.type);
858	return -1;	858	return -1;
859	}	859	}
860		860
861	process_raw_event(sample->raw_data, sample->cpu, sample->time, thread);	861	process_raw_event(sample->raw_data, sample->cpu, sample->time, thread);
862		862
863	return 0;	863	return 0;
864	}	864	}
865		865
866	static struct perf_event_ops eops = {	866	static struct perf_event_ops eops = {
867	.sample = process_sample_event,	867	.sample = process_sample_event,
868	.comm = perf_event__process_comm,	868	.comm = perf_event__process_comm,
869	.ordered_samples = true,	869	.ordered_samples = true,
870	};	870	};
871		871
872	static int read_events(void)	872	static int read_events(void)
873	{	873	{
874	session = perf_session__new(input_name, O_RDONLY, 0, false, &eops);	874	session = perf_session__new(input_name, O_RDONLY, 0, false, &eops);
875	if (!session)	875	if (!session)
876	die("Initializing perf session failed\n");	876	die("Initializing perf session failed\n");
877		877
878	return perf_session__process_events(session, &eops);	878	return perf_session__process_events(session, &eops);
879	}	879	}
880		880
881	static void sort_result(void)	881	static void sort_result(void)
882	{	882	{
883	unsigned int i;	883	unsigned int i;
884	struct lock_stat *st;	884	struct lock_stat *st;
885		885
886	for (i = 0; i < LOCKHASH_SIZE; i++) {	886	for (i = 0; i < LOCKHASH_SIZE; i++) {
887	list_for_each_entry(st, &lockhash_table[i], hash_entry) {	887	list_for_each_entry(st, &lockhash_table[i], hash_entry) {
888	insert_to_result(st, compare);	888	insert_to_result(st, compare);
889	}	889	}
890	}	890	}
891	}	891	}
892		892
893	static void __cmd_report(void)	893	static void __cmd_report(void)
894	{	894	{
895	setup_pager();	895	setup_pager();
896	select_key();	896	select_key();
897	read_events();	897	read_events();
898	sort_result();	898	sort_result();
899	print_result();	899	print_result();
900	}	900	}
901		901
902	static const char * const report_usage[] = {	902	static const char * const report_usage[] = {
903	"perf lock report [<options>]",	903	"perf lock report [<options>]",
904	NULL	904	NULL
905	};	905	};
906		906
907	static const struct option report_options[] = {	907	static const struct option report_options[] = {
908	OPT_STRING('k', "key", &sort_key, "acquired",	908	OPT_STRING('k', "key", &sort_key, "acquired",
909	"key for sorting (acquired / contended / wait_total / wait_max / wait_min)"),	909	"key for sorting (acquired / contended / wait_total / wait_max / wait_min)"),
910	/* TODO: type */	910	/* TODO: type */
911	OPT_END()	911	OPT_END()
912	};	912	};
913		913
914	static const char * const info_usage[] = {	914	static const char * const info_usage[] = {
915	"perf lock info [<options>]",	915	"perf lock info [<options>]",
916	NULL	916	NULL
917	};	917	};
918		918
919	static const struct option info_options[] = {	919	static const struct option info_options[] = {
920	OPT_BOOLEAN('t', "threads", &info_threads,	920	OPT_BOOLEAN('t', "threads", &info_threads,
921	"dump thread list in perf.data"),	921	"dump thread list in perf.data"),
922	OPT_BOOLEAN('m', "map", &info_map,	922	OPT_BOOLEAN('m', "map", &info_map,
923	"map of lock instances (name:address table)"),	923	"map of lock instances (name:address table)"),
924	OPT_END()	924	OPT_END()
925	};	925	};
926		926
927	static const char * const lock_usage[] = {	927	static const char * const lock_usage[] = {
928	"perf lock [<options>] {record\|trace\|report}",	928	"perf lock [<options>] {record\|trace\|report}",
929	NULL	929	NULL
930	};	930	};
931		931
932	static const struct option lock_options[] = {	932	static const struct option lock_options[] = {
933	OPT_STRING('i', "input", &input_name, "file", "input file name"),	933	OPT_STRING('i', "input", &input_name, "file", "input file name"),
934	OPT_INCR('v', "verbose", &verbose, "be more verbose (show symbol address, etc)"),	934	OPT_INCR('v', "verbose", &verbose, "be more verbose (show symbol address, etc)"),
935	OPT_BOOLEAN('D', "dump-raw-trace", &dump_trace, "dump raw trace in ASCII"),	935	OPT_BOOLEAN('D', "dump-raw-trace", &dump_trace, "dump raw trace in ASCII"),
936	OPT_END()	936	OPT_END()
937	};	937	};
938		938
939	static const char *record_args[] = {	939	static const char *record_args[] = {
940	"record",	940	"record",
941	"-R",	941	"-R",
942	"-f",	942	"-f",
943	"-m", "1024",	943	"-m", "1024",
944	"-c", "1",	944	"-c", "1",
945	"-e", "lock:lock_acquire:r",	945	"-e", "lock:lock_acquire",
946	"-e", "lock:lock_acquired:r",	946	"-e", "lock:lock_acquired",
947	"-e", "lock:lock_contended:r",	947	"-e", "lock:lock_contended",
948	"-e", "lock:lock_release:r",	948	"-e", "lock:lock_release",
949	};	949	};
950		950
951	static int __cmd_record(int argc, const char **argv)	951	static int __cmd_record(int argc, const char **argv)
952	{	952	{
953	unsigned int rec_argc, i, j;	953	unsigned int rec_argc, i, j;
954	const char **rec_argv;	954	const char **rec_argv;
955		955
956	rec_argc = ARRAY_SIZE(record_args) + argc - 1;	956	rec_argc = ARRAY_SIZE(record_args) + argc - 1;
957	rec_argv = calloc(rec_argc + 1, sizeof(char *));	957	rec_argv = calloc(rec_argc + 1, sizeof(char *));
958		958
959	if (rec_argv == NULL)	959	if (rec_argv == NULL)
960	return -ENOMEM;	960	return -ENOMEM;
961		961
962	for (i = 0; i < ARRAY_SIZE(record_args); i++)	962	for (i = 0; i < ARRAY_SIZE(record_args); i++)
963	rec_argv[i] = strdup(record_args[i]);	963	rec_argv[i] = strdup(record_args[i]);
964		964
965	for (j = 1; j < (unsigned int)argc; j++, i++)	965	for (j = 1; j < (unsigned int)argc; j++, i++)
966	rec_argv[i] = argv[j];	966	rec_argv[i] = argv[j];
967		967
968	BUG_ON(i != rec_argc);	968	BUG_ON(i != rec_argc);
969		969
970	return cmd_record(i, rec_argv, NULL);	970	return cmd_record(i, rec_argv, NULL);
971	}	971	}
972		972
973	int cmd_lock(int argc, const char *argv, const char prefix __used)	973	int cmd_lock(int argc, const char *argv, const char prefix __used)
974	{	974	{
975	unsigned int i;	975	unsigned int i;
976		976
977	symbol__init();	977	symbol__init();
978	for (i = 0; i < LOCKHASH_SIZE; i++)	978	for (i = 0; i < LOCKHASH_SIZE; i++)
979	INIT_LIST_HEAD(lockhash_table + i);	979	INIT_LIST_HEAD(lockhash_table + i);
980		980
981	argc = parse_options(argc, argv, lock_options, lock_usage,	981	argc = parse_options(argc, argv, lock_options, lock_usage,
982	PARSE_OPT_STOP_AT_NON_OPTION);	982	PARSE_OPT_STOP_AT_NON_OPTION);
983	if (!argc)	983	if (!argc)
984	usage_with_options(lock_usage, lock_options);	984	usage_with_options(lock_usage, lock_options);
985		985
986	if (!strncmp(argv[0], "rec", 3)) {	986	if (!strncmp(argv[0], "rec", 3)) {
987	return __cmd_record(argc, argv);	987	return __cmd_record(argc, argv);
988	} else if (!strncmp(argv[0], "report", 6)) {	988	} else if (!strncmp(argv[0], "report", 6)) {
989	trace_handler = &report_lock_ops;	989	trace_handler = &report_lock_ops;
990	if (argc) {	990	if (argc) {
991	argc = parse_options(argc, argv,	991	argc = parse_options(argc, argv,
992	report_options, report_usage, 0);	992	report_options, report_usage, 0);
993	if (argc)	993	if (argc)
994	usage_with_options(report_usage, report_options);	994	usage_with_options(report_usage, report_options);
995	}	995	}
996	__cmd_report();	996	__cmd_report();
997	} else if (!strcmp(argv[0], "script")) {	997	} else if (!strcmp(argv[0], "script")) {
998	/* Aliased to 'perf script' */	998	/* Aliased to 'perf script' */
999	return cmd_script(argc, argv, prefix);	999	return cmd_script(argc, argv, prefix);
1000	} else if (!strcmp(argv[0], "info")) {	1000	} else if (!strcmp(argv[0], "info")) {
1001	if (argc) {	1001	if (argc) {
1002	argc = parse_options(argc, argv,	1002	argc = parse_options(argc, argv,
1003	info_options, info_usage, 0);	1003	info_options, info_usage, 0);
1004	if (argc)	1004	if (argc)
1005	usage_with_options(info_usage, info_options);	1005	usage_with_options(info_usage, info_options);
1006	}	1006	}
1007	/* recycling report_lock_ops */	1007	/* recycling report_lock_ops */
1008	trace_handler = &report_lock_ops;	1008	trace_handler = &report_lock_ops;
1009	setup_pager();	1009	setup_pager();
1010	read_events();	1010	read_events();
1011	dump_info();	1011	dump_info();
1012	} else {	1012	} else {
1013	usage_with_options(lock_usage, lock_options);	1013	usage_with_options(lock_usage, lock_options);
1014	}	1014	}
1015		1015
1016	return 0;	1016	return 0;
1017	}	1017	}
1018		1018

tools/perf/builtin-record.c

Diff comments View file @ 1d229d5

 /*
  * builtin-record.c
  *
  * Builtin record command: Record the profile of a workload
  * (or a CPU, or a PID) into the perf.data output file - for
  * later analysis via perf report.
  */
 #define _FILE_OFFSET_BITS 64
 #include "builtin.h"
 #include "perf.h"
 #include "util/build-id.h"
 #include "util/util.h"
 #include "util/parse-options.h"
 #include "util/parse-events.h"
 #include "util/header.h"
 #include "util/event.h"
 #include "util/evlist.h"
 #include "util/evsel.h"
 #include "util/debug.h"
 #include "util/session.h"
 #include "util/symbol.h"
 #include "util/cpumap.h"
 #include "util/thread_map.h"
 #include <unistd.h>
 #include <sched.h>
 #include <sys/mman.h>
-#define FD(e, x, y) (*(int *)xyarray__entry(e->fd, x, y))
 enum write_mode_t {
 	WRITE_FORCE,
 	WRITE_APPEND
 };
 static u64			user_interval			= ULLONG_MAX;
 static u64			default_interval		=      0;
 static unsigned int		page_size;
 static unsigned int		mmap_pages			= UINT_MAX;
 static unsigned int		user_freq 			= UINT_MAX;
 static int			freq				=   1000;
 static int			output;
 static int			pipe_output			=      0;
 static const char		*output_name			= NULL;
 static int			group				=      0;
 static int			realtime_prio			=      0;
 static bool			nodelay				=  false;
 static bool			raw_samples			=  false;
 static bool			sample_id_all_avail		=   true;
 static bool			system_wide			=  false;
 static pid_t			target_pid			=     -1;
 static pid_t			target_tid			=     -1;
 static pid_t			child_pid			=     -1;
 static bool			no_inherit			=  false;
 static enum write_mode_t	write_mode			= WRITE_FORCE;
 static bool			call_graph			=  false;
 static bool			inherit_stat			=  false;
 static bool			no_samples			=  false;
 static bool			sample_address			=  false;
 static bool			sample_time			=  false;
 static bool			no_buildid			=  false;
 static bool			no_buildid_cache		=  false;
 static struct perf_evlist	*evsel_list;
 static long			samples				=      0;
 static u64			bytes_written			=      0;
 static int			file_new			=      1;
 static off_t			post_processing_offset;
 static struct perf_session	*session;
 static const char		*cpu_list;
 static void advance_output(size_t size)
 {
 	bytes_written += size;
 }
 static void write_output(void *buf, size_t size)
 {
 	while (size) {
 		int ret = write(output, buf, size);
 		if (ret < 0)
 			die("failed to write");
 		size -= ret;
 		buf += ret;
 		bytes_written += ret;
 	}
 }
 static int process_synthesized_event(union perf_event *event,
 				     struct perf_sample *sample __used,
 				     struct perf_session *self __used)
 {
 	write_output(event, event->header.size);
 	return 0;
 }
 static void mmap_read(struct perf_mmap *md)
 {
 	unsigned int head = perf_mmap__read_head(md);
 	unsigned int old = md->prev;
 	unsigned char *data = md->base + page_size;
 	unsigned long size;
 	void *buf;
 	if (old == head)
 		return;
 	samples++;
 	size = head - old;
 	if ((old & md->mask) + size != (head & md->mask)) {
 		buf = &data[old & md->mask];
 		size = md->mask + 1 - (old & md->mask);
 		old += size;
 		write_output(buf, size);
 	}
 	buf = &data[old & md->mask];
 	size = head - old;
 	old += size;
 	write_output(buf, size);
 	md->prev = old;
 	perf_mmap__write_tail(md, old);
 }
 static volatile int done = 0;
 static volatile int signr = -1;
 static void sig_handler(int sig)
 {
 	done = 1;
 	signr = sig;
 }
 static void sig_atexit(void)
 {
 	if (child_pid > 0)
 		kill(child_pid, SIGTERM);
 	if (signr == -1 || signr == SIGUSR1)
 		return;
 	signal(signr, SIG_DFL);
 	kill(getpid(), signr);
 }
 static void config_attr(struct perf_evsel *evsel, struct perf_evlist *evlist)
 {
 	struct perf_event_attr *attr = &evsel->attr;
 	int track = !evsel->idx; /* only the first counter needs these */
 	attr->inherit		= !no_inherit;
 	attr->read_format	= PERF_FORMAT_TOTAL_TIME_ENABLED |
 				  PERF_FORMAT_TOTAL_TIME_RUNNING |
 				  PERF_FORMAT_ID;
 	attr->sample_type	|= PERF_SAMPLE_IP | PERF_SAMPLE_TID;
 	if (evlist->nr_entries > 1)
 		attr->sample_type |= PERF_SAMPLE_ID;
 	/*
 	 * We default some events to a 1 default interval. But keep
 	 * it a weak assumption overridable by the user.
 	 */
 	if (!attr->sample_period || (user_freq != UINT_MAX &&
 				     user_interval != ULLONG_MAX)) {
 		if (freq) {
 			attr->sample_type	|= PERF_SAMPLE_PERIOD;
 			attr->freq		= 1;
 			attr->sample_freq	= freq;
 		} else {
 			attr->sample_period = default_interval;
 		}
 	}
 	if (no_samples)
 		attr->sample_freq = 0;
 	if (inherit_stat)
 		attr->inherit_stat = 1;
 	if (sample_address) {
 		attr->sample_type	|= PERF_SAMPLE_ADDR;
 		attr->mmap_data = track;
 	}
 	if (call_graph)
 		attr->sample_type	|= PERF_SAMPLE_CALLCHAIN;
 	if (system_wide)
 		attr->sample_type	|= PERF_SAMPLE_CPU;
 	if (sample_id_all_avail &&
 	    (sample_time || system_wide || !no_inherit || cpu_list))
 		attr->sample_type	|= PERF_SAMPLE_TIME;
 	if (raw_samples) {
 		attr->sample_type	|= PERF_SAMPLE_TIME;
 		attr->sample_type	|= PERF_SAMPLE_RAW;
 		attr->sample_type	|= PERF_SAMPLE_CPU;
 	}
 	if (nodelay) {
 		attr->watermark = 0;
 		attr->wakeup_events = 1;
 	}
 	attr->mmap		= track;
 	attr->comm		= track;
 	if (target_pid == -1 && target_tid == -1 && !system_wide) {
 		attr->disabled = 1;
 		attr->enable_on_exec = 1;
 	}
 }
 static bool perf_evlist__equal(struct perf_evlist *evlist,
 			       struct perf_evlist *other)
 {
 	struct perf_evsel *pos, *pair;
 	if (evlist->nr_entries != other->nr_entries)
 		return false;
 	pair = list_entry(other->entries.next, struct perf_evsel, node);
 	list_for_each_entry(pos, &evlist->entries, node) {
 		if (memcmp(&pos->attr, &pair->attr, sizeof(pos->attr) != 0))
 			return false;
 		pair = list_entry(pair->node.next, struct perf_evsel, node);
 	}
 	return true;
 }
 static void open_counters(struct perf_evlist *evlist)
 {
 	struct perf_evsel *pos;
 	if (evlist->cpus->map[0] < 0)
 		no_inherit = true;
 	list_for_each_entry(pos, &evlist->entries, node) {
 		struct perf_event_attr *attr = &pos->attr;
 		/*
 		 * Check if parse_single_tracepoint_event has already asked for
 		 * PERF_SAMPLE_TIME.
 		 *
 		 * XXX this is kludgy but short term fix for problems introduced by
 		 * eac23d1c that broke 'perf script' by having different sample_types
 		 * when using multiple tracepoint events when we use a perf binary
 		 * that tries to use sample_id_all on an older kernel.
 		 *
 		 * We need to move counter creation to perf_session, support
 		 * different sample_types, etc.
 		 */
 		bool time_needed = attr->sample_type & PERF_SAMPLE_TIME;
 		config_attr(pos, evlist);
 retry_sample_id:
 		attr->sample_id_all = sample_id_all_avail ? 1 : 0;
 try_again:
 		if (perf_evsel__open(pos, evlist->cpus, evlist->threads, group) < 0) {
 			int err = errno;
 			if (err == EPERM || err == EACCES) {
 				ui__warning_paranoid();
 				exit(EXIT_FAILURE);
 			} else if (err ==  ENODEV && cpu_list) {
 				die("No such device - did you specify"
 					" an out-of-range profile CPU?\n");
 			} else if (err == EINVAL && sample_id_all_avail) {
 				/*
 				 * Old kernel, no attr->sample_id_type_all field
 				 */
 				sample_id_all_avail = false;
 				if (!sample_time && !raw_samples && !time_needed)
 					attr->sample_type &= ~PERF_SAMPLE_TIME;
 				goto retry_sample_id;
 			}
 			/*
 			 * If it's cycles then fall back to hrtimer
 			 * based cpu-clock-tick sw counter, which
 			 * is always available even if no PMU support:
 			 */
 			if (attr->type == PERF_TYPE_HARDWARE
 					&& attr->config == PERF_COUNT_HW_CPU_CYCLES) {
 				if (verbose)
 					ui__warning("The cycles event is not supported, "
 						    "trying to fall back to cpu-clock-ticks\n");
 				attr->type = PERF_TYPE_SOFTWARE;
 				attr->config = PERF_COUNT_SW_CPU_CLOCK;
 				goto try_again;
 			}
 			if (err == ENOENT) {
 				ui__warning("The %s event is not supported.\n",
 					    event_name(pos));
 				exit(EXIT_FAILURE);
 			}
 			printf("\n");
 			error("sys_perf_event_open() syscall returned with %d (%s).  /bin/dmesg may provide additional information.\n",
 			      err, strerror(err));
 #if defined(__i386__) || defined(__x86_64__)
 			if (attr->type == PERF_TYPE_HARDWARE && err == EOPNOTSUPP)
 				die("No hardware sampling interrupt available."
 				    " No APIC? If so then you can boot the kernel"
 				    " with the \"lapic\" boot parameter to"
 				    " force-enable it.\n");
 #endif
 			die("No CONFIG_PERF_EVENTS=y kernel support configured?\n");
 		}
 	}
 	if (perf_evlist__set_filters(evlist)) {
 		error("failed to set filter with %d (%s)\n", errno,
 			strerror(errno));
 		exit(-1);
 	}
 	if (perf_evlist__mmap(evlist, mmap_pages, false) < 0)
 		die("failed to mmap with %d (%s)\n", errno, strerror(errno));
 	if (file_new)
 		session->evlist = evlist;
 	else {
 		if (!perf_evlist__equal(session->evlist, evlist)) {
 			fprintf(stderr, "incompatible append\n");
 			exit(-1);
 		}
  	}
 	perf_session__update_sample_type(session);
 }
 static int process_buildids(void)
 {
 	u64 size = lseek(output, 0, SEEK_CUR);
 	if (size == 0)
 		return 0;
 	session->fd = output;
 	return __perf_session__process_events(session, post_processing_offset,
 					      size - post_processing_offset,
 					      size, &build_id__mark_dso_hit_ops);
 }
 static void atexit_header(void)
 {
 	if (!pipe_output) {
 		session->header.data_size += bytes_written;
 		if (!no_buildid)
 			process_buildids();
 		perf_session__write_header(session, evsel_list, output, true);
 		perf_session__delete(session);
 		perf_evlist__delete(evsel_list);
 		symbol__exit();
 	}
 }
 static void perf_event__synthesize_guest_os(struct machine *machine, void *data)
 {
 	int err;
 	struct perf_session *psession = data;
 	if (machine__is_host(machine))
 		return;
 	/*
 	 *As for guest kernel when processing subcommand record&report,
 	 *we arrange module mmap prior to guest kernel mmap and trigger
 	 *a preload dso because default guest module symbols are loaded
 	 *from guest kallsyms instead of /lib/modules/XXX/XXX. This
 	 *method is used to avoid symbol missing when the first addr is
 	 *in module instead of in guest kernel.
 	 */
 	err = perf_event__synthesize_modules(process_synthesized_event,
 					     psession, machine);
 	if (err < 0)
 		pr_err("Couldn't record guest kernel [%d]'s reference"
 		       " relocation symbol.\n", machine->pid);
 	/*
 	 * We use _stext for guest kernel because guest kernel's /proc/kallsyms
 	 * have no _text sometimes.
 	 */
 	err = perf_event__synthesize_kernel_mmap(process_synthesized_event,
 						 psession, machine, "_text");
 	if (err < 0)
 		err = perf_event__synthesize_kernel_mmap(process_synthesized_event,
 							 psession, machine,
 							 "_stext");
 	if (err < 0)
 		pr_err("Couldn't record guest kernel [%d]'s reference"
 		       " relocation symbol.\n", machine->pid);
 }
 static struct perf_event_header finished_round_event = {
 	.size = sizeof(struct perf_event_header),
 	.type = PERF_RECORD_FINISHED_ROUND,
 };
 static void mmap_read_all(void)
 {
 	int i;
 	for (i = 0; i < evsel_list->nr_mmaps; i++) {
 		if (evsel_list->mmap[i].base)
 			mmap_read(&evsel_list->mmap[i]);
 	}
 	if (perf_header__has_feat(&session->header, HEADER_TRACE_INFO))
 		write_output(&finished_round_event, sizeof(finished_round_event));
 }
 static int __cmd_record(int argc, const char **argv)
 {
-	int i;
 	struct stat st;
 	int flags;
 	int err;
 	unsigned long waking = 0;
 	int child_ready_pipe[2], go_pipe[2];
 	const bool forks = argc > 0;
 	char buf;
 	struct machine *machine;
 	page_size = sysconf(_SC_PAGE_SIZE);
 	atexit(sig_atexit);
 	signal(SIGCHLD, sig_handler);
 	signal(SIGINT, sig_handler);
 	signal(SIGUSR1, sig_handler);
 	if (forks && (pipe(child_ready_pipe) < 0 || pipe(go_pipe) < 0)) {
 		perror("failed to create pipes");
 		exit(-1);
 	}
 	if (!output_name) {
 		if (!fstat(STDOUT_FILENO, &st) && S_ISFIFO(st.st_mode))
 			pipe_output = 1;
 		else
 			output_name = "perf.data";
 	}
 	if (output_name) {
 		if (!strcmp(output_name, "-"))
 			pipe_output = 1;
 		else if (!stat(output_name, &st) && st.st_size) {
 			if (write_mode == WRITE_FORCE) {
 				char oldname[PATH_MAX];
 				snprintf(oldname, sizeof(oldname), "%s.old",
 					 output_name);
 				unlink(oldname);
 				rename(output_name, oldname);
 			}
 		} else if (write_mode == WRITE_APPEND) {
 			write_mode = WRITE_FORCE;
 		}
 	}
 	flags = O_CREAT|O_RDWR;
 	if (write_mode == WRITE_APPEND)
 		file_new = 0;
 	else
 		flags |= O_TRUNC;
 	if (pipe_output)
 		output = STDOUT_FILENO;
 	else
 		output = open(output_name, flags, S_IRUSR | S_IWUSR);
 	if (output < 0) {
 		perror("failed to create output file");
 		exit(-1);
 	}
 	session = perf_session__new(output_name, O_WRONLY,
 				    write_mode == WRITE_FORCE, false, NULL);
 	if (session == NULL) {
 		pr_err("Not enough memory for reading perf file header\n");
 		return -1;
 	}
 	if (!no_buildid)
 		perf_header__set_feat(&session->header, HEADER_BUILD_ID);
 	if (!file_new) {
 		err = perf_session__read_header(session, output);
 		if (err < 0)
 			goto out_delete_session;
 	}
 	if (have_tracepoints(&evsel_list->entries))
 		perf_header__set_feat(&session->header, HEADER_TRACE_INFO);
 	/* 512 kiB: default amount of unprivileged mlocked memory */
 	if (mmap_pages == UINT_MAX)
 		mmap_pages = (512 * 1024) / page_size;
 	if (forks) {
 		child_pid = fork();
 		if (child_pid < 0) {
 			perror("failed to fork");
 			exit(-1);
 		}
 		if (!child_pid) {
 			if (pipe_output)
 				dup2(2, 1);
 			close(child_ready_pipe[0]);
 			close(go_pipe[1]);
 			fcntl(go_pipe[0], F_SETFD, FD_CLOEXEC);
 			/*
 			 * Do a dummy execvp to get the PLT entry resolved,
 			 * so we avoid the resolver overhead on the real
 			 * execvp call.
 			 */
 			execvp("", (char **)argv);
 			/*
 			 * Tell the parent we're ready to go
 			 */
 			close(child_ready_pipe[1]);
 			/*
 			 * Wait until the parent tells us to go.
 			 */
 			if (read(go_pipe[0], &buf, 1) == -1)
 				perror("unable to read pipe");
 			execvp(argv[0], (char **)argv);
 			perror(argv[0]);
 			kill(getppid(), SIGUSR1);
 			exit(-1);
 		}
 		if (!system_wide && target_tid == -1 && target_pid == -1)
 			evsel_list->threads->map[0] = child_pid;
 		close(child_ready_pipe[1]);
 		close(go_pipe[0]);
 		/*
 		 * wait for child to settle
 		 */
 		if (read(child_ready_pipe[0], &buf, 1) == -1) {
 			perror("unable to read pipe");
 			exit(-1);
 		}
 		close(child_ready_pipe[0]);
 	}
 	open_counters(evsel_list);
 	/*
 	 * perf_session__delete(session) will be called at atexit_header()
 	 */
 	atexit(atexit_header);
 	if (pipe_output) {
 		err = perf_header__write_pipe(output);
 		if (err < 0)
 			return err;
 	} else if (file_new) {
 		err = perf_session__write_header(session, evsel_list,
 						 output, false);
 		if (err < 0)
 			return err;
 	}
 	post_processing_offset = lseek(output, 0, SEEK_CUR);
 	if (pipe_output) {
 		err = perf_session__synthesize_attrs(session,
 						     process_synthesized_event);
 		if (err < 0) {
 			pr_err("Couldn't synthesize attrs.\n");
 			return err;
 		}
 		err = perf_event__synthesize_event_types(process_synthesized_event,
 							 session);
 		if (err < 0) {
 			pr_err("Couldn't synthesize event_types.\n");
 			return err;
 		}
 		if (have_tracepoints(&evsel_list->entries)) {
 			/*
 			 * FIXME err <= 0 here actually means that
 			 * there were no tracepoints so its not really
 			 * an error, just that we don't need to
 			 * synthesize anything.  We really have to
 			 * return this more properly and also
 			 * propagate errors that now are calling die()
 			 */
 			err = perf_event__synthesize_tracing_data(output, evsel_list,
 								  process_synthesized_event,
 								  session);
 			if (err <= 0) {
 				pr_err("Couldn't record tracing data.\n");
 				return err;
 			}
 			advance_output(err);
 		}
 	}
 	machine = perf_session__find_host_machine(session);
 	if (!machine) {
 		pr_err("Couldn't find native kernel information.\n");
 		return -1;
 	}
 	err = perf_event__synthesize_kernel_mmap(process_synthesized_event,
 						 session, machine, "_text");
 	if (err < 0)
 		err = perf_event__synthesize_kernel_mmap(process_synthesized_event,
 							 session, machine, "_stext");
 	if (err < 0)
 		pr_err("Couldn't record kernel reference relocation symbol\n"
 		       "Symbol resolution may be skewed if relocation was used (e.g. kexec).\n"
 		       "Check /proc/kallsyms permission or run as root.\n");
 	err = perf_event__synthesize_modules(process_synthesized_event,
 					     session, machine);
 	if (err < 0)
 		pr_err("Couldn't record kernel module information.\n"
 		       "Symbol resolution may be skewed if relocation was used (e.g. kexec).\n"
 		       "Check /proc/modules permission or run as root.\n");
 	if (perf_guest)
 		perf_session__process_machines(session,
 					       perf_event__synthesize_guest_os);
 	if (!system_wide)
 		perf_event__synthesize_thread_map(evsel_list->threads,
 						  process_synthesized_event,
 						  session);
 	else
 		perf_event__synthesize_threads(process_synthesized_event,
 					       session);
 	if (realtime_prio) {
 		struct sched_param param;
 		param.sched_priority = realtime_prio;
 		if (sched_setscheduler(0, SCHED_FIFO, &param)) {
 			pr_err("Could not set realtime priority.\n");
 			exit(-1);
 		}
 	}
 	/*
 	 * Let the child rip
 	 */
 	if (forks)
 		close(go_pipe[1]);
 	for (;;) {
 		int hits = samples;
-		int thread;
 		mmap_read_all();
 		if (hits == samples) {
 			if (done)
 				break;
 			err = poll(evsel_list->pollfd, evsel_list->nr_fds, -1);
 			waking++;
 		}
-		if (done) {
+		if (done)
-			for (i = 0; i < evsel_list->cpus->nr; i++) {
+			perf_evlist__disable(evsel_list);
-				struct perf_evsel *pos;
-				list_for_each_entry(pos, &evsel_list->entries, node) {
-					for (thread = 0;
-						thread < evsel_list->threads->nr;
-						thread++)
-						ioctl(FD(pos, i, thread),
-							PERF_EVENT_IOC_DISABLE);
-				}
-			}
-		}
 	}
 	if (quiet || signr == SIGUSR1)
 		return 0;
 	fprintf(stderr, "[ perf record: Woken up %ld times to write data ]\n", waking);
 	/*
 	 * Approximate RIP event size: 24 bytes.
 	 */
 	fprintf(stderr,
 		"[ perf record: Captured and wrote %.3f MB %s (~%" PRIu64 " samples) ]\n",
 		(double)bytes_written / 1024.0 / 1024.0,
 		output_name,
 		bytes_written / 24);
 	return 0;
 out_delete_session:
 	perf_session__delete(session);
 	return err;
 }
 static const char * const record_usage[] = {
 	"perf record [<options>] [<command>]",
 	"perf record [<options>] -- <command> [<options>]",
 	NULL
 };
 static bool force, append_file;
 const struct option record_options[] = {
 	OPT_CALLBACK('e', "event", &evsel_list, "event",
 		     "event selector. use 'perf list' to list available events",
 		     parse_events_option),
 	OPT_CALLBACK(0, "filter", &evsel_list, "filter",
 		     "event filter", parse_filter),
 	OPT_INTEGER('p', "pid", &target_pid,
 		    "record events on existing process id"),
 	OPT_INTEGER('t', "tid", &target_tid,
 		    "record events on existing thread id"),
 	OPT_INTEGER('r', "realtime", &realtime_prio,
 		    "collect data with this RT SCHED_FIFO priority"),
 	OPT_BOOLEAN('D', "no-delay", &nodelay,
 		    "collect data without buffering"),
 	OPT_BOOLEAN('R', "raw-samples", &raw_samples,
 		    "collect raw sample records from all opened counters"),
 	OPT_BOOLEAN('a', "all-cpus", &system_wide,
 			    "system-wide collection from all CPUs"),
 	OPT_BOOLEAN('A', "append", &append_file,
 			    "append to the output file to do incremental profiling"),
 	OPT_STRING('C', "cpu", &cpu_list, "cpu",
 		    "list of cpus to monitor"),
 	OPT_BOOLEAN('f', "force", &force,
 			"overwrite existing data file (deprecated)"),
 	OPT_U64('c', "count", &user_interval, "event period to sample"),
 	OPT_STRING('o', "output", &output_name, "file",
 		    "output file name"),
 	OPT_BOOLEAN('i', "no-inherit", &no_inherit,
 		    "child tasks do not inherit counters"),
 	OPT_UINTEGER('F', "freq", &user_freq, "profile at this frequency"),
 	OPT_UINTEGER('m', "mmap-pages", &mmap_pages, "number of mmap data pages"),
 	OPT_BOOLEAN('g', "call-graph", &call_graph,
 		    "do call-graph (stack chain/backtrace) recording"),
 	OPT_INCR('v', "verbose", &verbose,
 		    "be more verbose (show counter open errors, etc)"),
 	OPT_BOOLEAN('q', "quiet", &quiet, "don't print any message"),
 	OPT_BOOLEAN('s', "stat", &inherit_stat,
 		    "per thread counts"),
 	OPT_BOOLEAN('d', "data", &sample_address,
 		    "Sample addresses"),
 	OPT_BOOLEAN('T', "timestamp", &sample_time, "Sample timestamps"),
 	OPT_BOOLEAN('n', "no-samples", &no_samples,
 		    "don't sample"),
 	OPT_BOOLEAN('N', "no-buildid-cache", &no_buildid_cache,
 		    "do not update the buildid cache"),
 	OPT_BOOLEAN('B', "no-buildid", &no_buildid,
 		    "do not collect buildids in perf.data"),
 	OPT_CALLBACK('G', "cgroup", &evsel_list, "name",
 		     "monitor event in cgroup name only",
 		     parse_cgroups),
 	OPT_END()
 };
 int cmd_record(int argc, const char **argv, const char *prefix __used)
 {
 	int err = -ENOMEM;
 	struct perf_evsel *pos;
 	evsel_list = perf_evlist__new(NULL, NULL);
 	if (evsel_list == NULL)
 		return -ENOMEM;
 	argc = parse_options(argc, argv, record_options, record_usage,
 			    PARSE_OPT_STOP_AT_NON_OPTION);
 	if (!argc && target_pid == -1 && target_tid == -1 &&
 		!system_wide && !cpu_list)
 		usage_with_options(record_usage, record_options);
 	if (force && append_file) {
 		fprintf(stderr, "Can't overwrite and append at the same time."
 				" You need to choose between -f and -A");
 		usage_with_options(record_usage, record_options);
 	} else if (append_file) {
 		write_mode = WRITE_APPEND;
 	} else {
 		write_mode = WRITE_FORCE;
 	}
 	if (nr_cgroups && !system_wide) {
 		fprintf(stderr, "cgroup monitoring only available in"
 			" system-wide mode\n");
 		usage_with_options(record_usage, record_options);
 	}
 	symbol__init();
 	if (symbol_conf.kptr_restrict)
 		pr_warning(
 "WARNING: Kernel address maps (/proc/{kallsyms,modules}) are restricted,\n"
 "check /proc/sys/kernel/kptr_restrict.\n\n"
 "Samples in kernel functions may not be resolved if a suitable vmlinux\n"
 "file is not found in the buildid cache or in the vmlinux path.\n\n"
 "Samples in kernel modules won't be resolved at all.\n\n"
 "If some relocation was applied (e.g. kexec) symbols may be misresolved\n"
 "even with a suitable vmlinux or kallsyms file.\n\n");
 	if (no_buildid_cache || no_buildid)
 		disable_buildid_cache();
 	if (evsel_list->nr_entries == 0 &&
 	    perf_evlist__add_default(evsel_list) < 0) {
 		pr_err("Not enough memory for event selector list\n");
 		goto out_symbol_exit;
 	}
 	if (target_pid != -1)
 		target_tid = target_pid;
 	if (perf_evlist__create_maps(evsel_list, target_pid,
 				     target_tid, cpu_list) < 0)
 		usage_with_options(record_usage, record_options);
 	list_for_each_entry(pos, &evsel_list->entries, node) {
 		if (perf_evsel__alloc_fd(pos, evsel_list->cpus->nr,
 					 evsel_list->threads->nr) < 0)
 			goto out_free_fd;
 		if (perf_header__push_event(pos->attr.config, event_name(pos)))
 			goto out_free_fd;
 	}
 	if (perf_evlist__alloc_pollfd(evsel_list) < 0)
 		goto out_free_fd;
 	if (user_interval != ULLONG_MAX)
 		default_interval = user_interval;
 	if (user_freq != UINT_MAX)
 		freq = user_freq;
 	/*
 	 * User specified count overrides default frequency.
 	 */
 	if (default_interval)
 		freq = 0;
 	else if (freq) {
 		default_interval = freq;
 	} else {
 		fprintf(stderr, "frequency and count are zero, aborting\n");
 		err = -EINVAL;
 		goto out_free_fd;
 	}
 	err = __cmd_record(argc, argv);
 out_free_fd:
 	perf_evlist__delete_maps(evsel_list);
 out_symbol_exit:
 	symbol__exit();
 	return err;
 }

tools/perf/builtin-report.c

Diff comments View file @ 1d229d5

 /*
  * builtin-report.c
  *
  * Builtin report command: Analyze the perf.data input file,
  * look up and read DSOs and symbol information and display
  * a histogram of results, along various sorting keys.
  */
 #include "builtin.h"
 #include "util/util.h"
 #include "util/annotate.h"
 #include "util/color.h"
 #include <linux/list.h>
 #include "util/cache.h"
 #include <linux/rbtree.h>
 #include "util/symbol.h"
 #include "util/callchain.h"
 #include "util/strlist.h"
 #include "util/values.h"
 #include "perf.h"
 #include "util/debug.h"
 #include "util/evlist.h"
 #include "util/evsel.h"
 #include "util/header.h"
 #include "util/session.h"
 #include "util/parse-options.h"
 #include "util/parse-events.h"
 #include "util/thread.h"
 #include "util/sort.h"
 #include "util/hist.h"
 #include <linux/bitmap.h>
 static char		const *input_name = "perf.data";
 static bool		force, use_tui, use_stdio;
 static bool		hide_unresolved;
 static bool		dont_use_callchains;
 static bool		show_threads;
 static struct perf_read_values	show_threads_values;
 static const char	default_pretty_printing_style[] = "normal";
 static const char	*pretty_printing_style = default_pretty_printing_style;
 static char		callchain_default_opt[] = "fractal,0.5,callee";
 static bool		inverted_callchain;
 static symbol_filter_t	annotate_init;
 static const char	*cpu_list;
 static DECLARE_BITMAP(cpu_bitmap, MAX_NR_CPUS);
 static int perf_session__add_hist_entry(struct perf_session *session,
 					struct addr_location *al,
 					struct perf_sample *sample,
 					struct perf_evsel *evsel)
 {
 	struct symbol *parent = NULL;
 	int err = 0;
 	struct hist_entry *he;
 	if ((sort__has_parent || symbol_conf.use_callchain) && sample->callchain) {
 		err = perf_session__resolve_callchain(session, al->thread,
 						      sample->callchain, &parent);
 		if (err)
 			return err;
 	}
 	he = __hists__add_entry(&evsel->hists, al, parent, sample->period);
 	if (he == NULL)
 		return -ENOMEM;
 	if (symbol_conf.use_callchain) {
 		err = callchain_append(he->callchain, &session->callchain_cursor,
 				       sample->period);
 		if (err)
 			return err;
 	}
 	/*
 	 * Only in the newt browser we are doing integrated annotation,
 	 * so we don't allocated the extra space needed because the stdio
 	 * code will not use it.
 	 */
 	if (al->sym != NULL && use_browser > 0) {
 		struct annotation *notes = symbol__annotation(he->ms.sym);
 		assert(evsel != NULL);
 		err = -ENOMEM;
 		if (notes->src == NULL &&
 		    symbol__alloc_hist(he->ms.sym, session->evlist->nr_entries) < 0)
 			goto out;
 		err = hist_entry__inc_addr_samples(he, evsel->idx, al->addr);
 	}
 	evsel->hists.stats.total_period += sample->period;
 	hists__inc_nr_events(&evsel->hists, PERF_RECORD_SAMPLE);
 out:
 	return err;
 }
 static int process_sample_event(union perf_event *event,
 				struct perf_sample *sample,
 				struct perf_evsel *evsel,
 				struct perf_session *session)
 {
 	struct addr_location al;
 	if (perf_event__preprocess_sample(event, session, &al, sample,
 					  annotate_init) < 0) {
 		fprintf(stderr, "problem processing %d event, skipping it.\n",
 			event->header.type);
 		return -1;
 	}
 	if (al.filtered || (hide_unresolved && al.sym == NULL))
 		return 0;
 	if (cpu_list && !test_bit(sample->cpu, cpu_bitmap))
 		return 0;
 	if (al.map != NULL)
 		al.map->dso->hit = 1;
 	if (perf_session__add_hist_entry(session, &al, sample, evsel)) {
 		pr_debug("problem incrementing symbol period, skipping event\n");
 		return -1;
 	}
 	return 0;
 }
 static int process_read_event(union perf_event *event,
 			      struct perf_sample *sample __used,
 			      struct perf_session *session)
 {
 	struct perf_evsel *evsel = perf_evlist__id2evsel(session->evlist,
 							 event->read.id);
 	if (show_threads) {
 		const char *name = evsel ? event_name(evsel) : "unknown";
 		perf_read_values_add_value(&show_threads_values,
 					   event->read.pid, event->read.tid,
 					   event->read.id,
 					   name,
 					   event->read.value);
 	}
 	dump_printf(": %d %d %s %" PRIu64 "\n", event->read.pid, event->read.tid,
 		    evsel ? event_name(evsel) : "FAIL",
 		    event->read.value);
 	return 0;
 }
 static int perf_session__setup_sample_type(struct perf_session *self)
 {
 	if (!(self->sample_type & PERF_SAMPLE_CALLCHAIN)) {
 		if (sort__has_parent) {
-			fprintf(stderr, "selected --sort parent, but no"
+			ui__warning("Selected --sort parent, but no "
-					" callchain data. Did you call"
+				    "callchain data. Did you call "
-					" perf record without -g?\n");
+				    "'perf record' without -g?\n");
 			return -EINVAL;
 		}
 		if (symbol_conf.use_callchain) {
-			fprintf(stderr, "selected -g but no callchain data."
+			ui__warning("Selected -g but no callchain data. Did "
-					" Did you call perf record without"
+				    "you call 'perf record' without -g?\n");
-					" -g?\n");
 			return -1;
 		}
 	} else if (!dont_use_callchains && callchain_param.mode != CHAIN_NONE &&
 		   !symbol_conf.use_callchain) {
 			symbol_conf.use_callchain = true;
 			if (callchain_register_param(&callchain_param) < 0) {
-				fprintf(stderr, "Can't register callchain"
+				ui__warning("Can't register callchain "
-						" params\n");
+					    "params.\n");
 				return -EINVAL;
 			}
 	}
 	return 0;
 }
 static struct perf_event_ops event_ops = {
 	.sample		 = process_sample_event,
 	.mmap		 = perf_event__process_mmap,
 	.comm		 = perf_event__process_comm,
 	.exit		 = perf_event__process_task,
 	.fork		 = perf_event__process_task,
 	.lost		 = perf_event__process_lost,
 	.read		 = process_read_event,
 	.attr		 = perf_event__process_attr,
 	.event_type	 = perf_event__process_event_type,
 	.tracing_data	 = perf_event__process_tracing_data,
 	.build_id	 = perf_event__process_build_id,
 	.ordered_samples = true,
 	.ordering_requires_timestamps = true,
 };
 extern volatile int session_done;
 static void sig_handler(int sig __used)
 {
 	session_done = 1;
 }
 static size_t hists__fprintf_nr_sample_events(struct hists *self,
 					      const char *evname, FILE *fp)
 {
 	size_t ret;
 	char unit;
 	unsigned long nr_events = self->stats.nr_events[PERF_RECORD_SAMPLE];
 	nr_events = convert_unit(nr_events, &unit);
 	ret = fprintf(fp, "# Events: %lu%c", nr_events, unit);
 	if (evname != NULL)
 		ret += fprintf(fp, " %s", evname);
 	return ret + fprintf(fp, "\n#\n");
 }
 static int perf_evlist__tty_browse_hists(struct perf_evlist *evlist,
 					 const char *help)
 {
 	struct perf_evsel *pos;
 	list_for_each_entry(pos, &evlist->entries, node) {
 		struct hists *hists = &pos->hists;
 		const char *evname = NULL;
 		if (rb_first(&hists->entries) != rb_last(&hists->entries))
 			evname = event_name(pos);
 		hists__fprintf_nr_sample_events(hists, evname, stdout);
 		hists__fprintf(hists, NULL, false, stdout);
 		fprintf(stdout, "\n\n");
 	}
 	if (sort_order == default_sort_order &&
 	    parent_pattern == default_parent_pattern) {
 		fprintf(stdout, "#\n# (%s)\n#\n", help);
 		if (show_threads) {
 			bool style = !strcmp(pretty_printing_style, "raw");
 			perf_read_values_display(stdout, &show_threads_values,
 						 style);
 			perf_read_values_destroy(&show_threads_values);
 		}
 	}
 	return 0;
 }
 static int __cmd_report(void)
 {
 	int ret = -EINVAL;
 	u64 nr_samples;
 	struct perf_session *session;
 	struct perf_evsel *pos;
 	struct map *kernel_map;
 	struct kmap *kernel_kmap;
 	const char *help = "For a higher level overview, try: perf report --sort comm,dso";
 	signal(SIGINT, sig_handler);
 	session = perf_session__new(input_name, O_RDONLY, force, false, &event_ops);
 	if (session == NULL)
 		return -ENOMEM;
 	if (cpu_list) {
 		ret = perf_session__cpu_bitmap(session, cpu_list, cpu_bitmap);
 		if (ret)
 			goto out_delete;
 	}
 	if (show_threads)
 		perf_read_values_init(&show_threads_values);
 	ret = perf_session__setup_sample_type(session);
 	if (ret)
 		goto out_delete;
 	ret = perf_session__process_events(session, &event_ops);
 	if (ret)
 		goto out_delete;
 	kernel_map = session->host_machine.vmlinux_maps[MAP__FUNCTION];
 	kernel_kmap = map__kmap(kernel_map);
 	if (kernel_map == NULL ||
 	    (kernel_map->dso->hit &&
 	     (kernel_kmap->ref_reloc_sym == NULL ||
 	      kernel_kmap->ref_reloc_sym->addr == 0))) {
 		const struct dso *kdso = kernel_map->dso;
 		ui__warning(
 "Kernel address maps (/proc/{kallsyms,modules}) were restricted.\n\n"
 "Check /proc/sys/kernel/kptr_restrict before running 'perf record'.\n\n%s\n\n"
 "Samples in kernel modules can't be resolved as well.\n\n",
 			    RB_EMPTY_ROOT(&kdso->symbols[MAP__FUNCTION]) ?
 "As no suitable kallsyms nor vmlinux was found, kernel samples\n"
 "can't be resolved." :
 "If some relocation was applied (e.g. kexec) symbols may be misresolved.");
 	}
 	if (dump_trace) {
 		perf_session__fprintf_nr_events(session, stdout);
 		goto out_delete;
 	}
 	if (verbose > 3)
 		perf_session__fprintf(session, stdout);
 	if (verbose > 2)
 		perf_session__fprintf_dsos(session, stdout);
 	nr_samples = 0;
 	list_for_each_entry(pos, &session->evlist->entries, node) {
 		struct hists *hists = &pos->hists;
 		hists__collapse_resort(hists);
 		hists__output_resort(hists);
 		nr_samples += hists->stats.nr_events[PERF_RECORD_SAMPLE];
 	}
 	if (nr_samples == 0) {
 		ui__warning("The %s file has no samples!\n", input_name);
 		goto out_delete;
 	}
 	if (use_browser > 0)
 		perf_evlist__tui_browse_hists(session->evlist, help);
 	else
 		perf_evlist__tty_browse_hists(session->evlist, help);
 out_delete:
 	/*
 	 * Speed up the exit process, for large files this can
 	 * take quite a while.
 	 *
 	 * XXX Enable this when using valgrind or if we ever
 	 * librarize this command.
 	 *
 	 * Also experiment with obstacks to see how much speed
 	 * up we'll get here.
 	 *
  	 * perf_session__delete(session);
  	 */
 	return ret;
 }
 static int
 parse_callchain_opt(const struct option *opt __used, const char *arg,
 		    int unset)
 {
 	char *tok, *tok2;
 	char *endptr;
 	/*
 	 * --no-call-graph
 	 */
 	if (unset) {
 		dont_use_callchains = true;
 		return 0;
 	}
 	symbol_conf.use_callchain = true;
 	if (!arg)
 		return 0;
 	tok = strtok((char *)arg, ",");
 	if (!tok)
 		return -1;
 	/* get the output mode */
 	if (!strncmp(tok, "graph", strlen(arg)))
 		callchain_param.mode = CHAIN_GRAPH_ABS;
 	else if (!strncmp(tok, "flat", strlen(arg)))
 		callchain_param.mode = CHAIN_FLAT;
 	else if (!strncmp(tok, "fractal", strlen(arg)))
 		callchain_param.mode = CHAIN_GRAPH_REL;
 	else if (!strncmp(tok, "none", strlen(arg))) {
 		callchain_param.mode = CHAIN_NONE;
 		symbol_conf.use_callchain = false;
 		return 0;
 	}
 	else
 		return -1;
 	/* get the min percentage */
 	tok = strtok(NULL, ",");
 	if (!tok)
 		goto setup;
 	callchain_param.min_percent = strtod(tok, &endptr);
 	if (tok == endptr)
 		return -1;
 	/* get the print limit */
 	tok2 = strtok(NULL, ",");
 	if (!tok2)
 		goto setup;
 	if (tok2[0] != 'c') {
 		callchain_param.print_limit = strtod(tok2, &endptr);
 		tok2 = strtok(NULL, ",");
 		if (!tok2)
 			goto setup;
 	}
 	/* get the call chain order */
 	if (!strcmp(tok2, "caller"))
 		callchain_param.order = ORDER_CALLER;
 	else if (!strcmp(tok2, "callee"))
 		callchain_param.order = ORDER_CALLEE;
 	else
 		return -1;
 setup:
 	if (callchain_register_param(&callchain_param) < 0) {
 		fprintf(stderr, "Can't register callchain params\n");
 		return -1;
 	}
 	return 0;
 }
 static const char * const report_usage[] = {
 	"perf report [<options>] <command>",
 	NULL
 };
 static const struct option options[] = {
 	OPT_STRING('i', "input", &input_name, "file",
 		    "input file name"),
 	OPT_INCR('v', "verbose", &verbose,
 		    "be more verbose (show symbol address, etc)"),
 	OPT_BOOLEAN('D', "dump-raw-trace", &dump_trace,
 		    "dump raw trace in ASCII"),
 	OPT_STRING('k', "vmlinux", &symbol_conf.vmlinux_name,
 		   "file", "vmlinux pathname"),
 	OPT_STRING(0, "kallsyms", &symbol_conf.kallsyms_name,
 		   "file", "kallsyms pathname"),
 	OPT_BOOLEAN('f', "force", &force, "don't complain, do it"),
 	OPT_BOOLEAN('m', "modules", &symbol_conf.use_modules,
 		    "load module symbols - WARNING: use only with -k and LIVE kernel"),
 	OPT_BOOLEAN('n', "show-nr-samples", &symbol_conf.show_nr_samples,
 		    "Show a column with the number of samples"),
 	OPT_BOOLEAN('T', "threads", &show_threads,
 		    "Show per-thread event counters"),
 	OPT_STRING(0, "pretty", &pretty_printing_style, "key",
 		   "pretty printing style key: normal raw"),
 	OPT_BOOLEAN(0, "tui", &use_tui, "Use the TUI interface"),
 	OPT_BOOLEAN(0, "stdio", &use_stdio, "Use the stdio interface"),
 	OPT_STRING('s', "sort", &sort_order, "key[,key2...]",
 		   "sort by key(s): pid, comm, dso, symbol, parent"),
 	OPT_BOOLEAN(0, "showcpuutilization", &symbol_conf.show_cpu_utilization,
 		    "Show sample percentage for different cpu modes"),
 	OPT_STRING('p', "parent", &parent_pattern, "regex",
 		   "regex filter to identify parent, see: '--sort parent'"),
 	OPT_BOOLEAN('x', "exclude-other", &symbol_conf.exclude_other,
 		    "Only display entries with parent-match"),
 	OPT_CALLBACK_DEFAULT('g', "call-graph", NULL, "output_type,min_percent, call_order",
 		     "Display callchains using output_type (graph, flat, fractal, or none) , min percent threshold and callchain order. "
 		     "Default: fractal,0.5,callee", &parse_callchain_opt, callchain_default_opt),
 	OPT_BOOLEAN('G', "inverted", &inverted_callchain, "alias for inverted call graph"),
 	OPT_STRING('d', "dsos", &symbol_conf.dso_list_str, "dso[,dso...]",
 		   "only consider symbols in these dsos"),
 	OPT_STRING('C', "comms", &symbol_conf.comm_list_str, "comm[,comm...]",
 		   "only consider symbols in these comms"),
 	OPT_STRING('S', "symbols", &symbol_conf.sym_list_str, "symbol[,symbol...]",
 		   "only consider these symbols"),
 	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_STRING('t', "field-separator", &symbol_conf.field_sep, "separator",
 		   "separator for columns, no spaces will be added between "
 		   "columns '.' is reserved."),
 	OPT_BOOLEAN('U', "hide-unresolved", &hide_unresolved,
 		    "Only display entries resolved to a symbol"),
 	OPT_STRING(0, "symfs", &symbol_conf.symfs, "directory",
 		    "Look for files with symbols relative to this directory"),
 	OPT_STRING('c', "cpu", &cpu_list, "cpu", "list of cpus to profile"),
 	OPT_END()
 };
 int cmd_report(int argc, const char **argv, const char *prefix __used)
 {
 	argc = parse_options(argc, argv, options, report_usage, 0);
 	if (use_stdio)
 		use_browser = 0;
 	else if (use_tui)
 		use_browser = 1;
 	if (inverted_callchain)
 		callchain_param.order = ORDER_CALLER;
 	if (strcmp(input_name, "-") != 0)
 		setup_browser(true);
 	else
 		use_browser = 0;
 	/*
 	 * Only in the newt browser we are doing integrated annotation,
 	 * so don't allocate extra space that won't be used in the stdio
 	 * implementation.
 	 */
 	if (use_browser > 0) {
 		symbol_conf.priv_size = sizeof(struct annotation);
 		annotate_init	      = symbol__annotate_init;
 		/*
  		 * For searching by name on the "Browse map details".
  		 * providing it only in verbose mode not to bloat too
  		 * much struct symbol.
  		 */
 		if (verbose) {
 			/*
 			 * XXX: Need to provide a less kludgy way to ask for
 			 * more space per symbol, the u32 is for the index on
 			 * the ui browser.
 			 * See symbol__browser_index.
 			 */
 			symbol_conf.priv_size += sizeof(u32);
 			symbol_conf.sort_by_name = true;
 		}
 	}
 	if (symbol__init() < 0)
 		return -1;
 	setup_sorting(report_usage, options);
 	if (parent_pattern != default_parent_pattern) {
 		if (sort_dimension__add("parent") < 0)
 			return -1;
 		/*
 		 * Only show the parent fields if we explicitly
 		 * sort that way. If we only use parent machinery
 		 * for filtering, we don't want it.
 		 */
 		if (!strstr(sort_order, "parent"))
 			sort_parent.elide = 1;
 	} else
 		symbol_conf.exclude_other = false;
 	/*
 	 * Any (unrecognized) arguments left?
 	 */
 	if (argc)
 		usage_with_options(report_usage, options);
 	sort_entry__setup_elide(&sort_dso, symbol_conf.dso_list, "dso", stdout);
 	sort_entry__setup_elide(&sort_comm, symbol_conf.comm_list, "comm", stdout);
 	sort_entry__setup_elide(&sort_sym, symbol_conf.sym_list, "symbol", stdout);
 	return __cmd_report();
 }

tools/perf/builtin-sched.c

Diff comments View file @ 1d229d5

 #include "builtin.h"
 #include "perf.h"
 #include "util/util.h"
 #include "util/cache.h"
 #include "util/symbol.h"
 #include "util/thread.h"
 #include "util/header.h"
 #include "util/session.h"
 #include "util/parse-options.h"
 #include "util/trace-event.h"
 #include "util/debug.h"
 #include <sys/prctl.h>
 #include <semaphore.h>
 #include <pthread.h>
 #include <math.h>
 static char			const *input_name = "perf.data";
 static char			default_sort_order[] = "avg, max, switch, runtime";
 static const char		*sort_order = default_sort_order;
 static int			profile_cpu = -1;
 #define PR_SET_NAME		15               /* Set process name */
 #define MAX_CPUS		4096
 static u64			run_measurement_overhead;
 static u64			sleep_measurement_overhead;
 #define COMM_LEN		20
 #define SYM_LEN			129
 #define MAX_PID			65536
 static unsigned long		nr_tasks;
 struct sched_atom;
 struct task_desc {
 	unsigned long		nr;
 	unsigned long		pid;
 	char			comm[COMM_LEN];
 	unsigned long		nr_events;
 	unsigned long		curr_event;
 	struct sched_atom	**atoms;
 	pthread_t		thread;
 	sem_t			sleep_sem;
 	sem_t			ready_for_work;
 	sem_t			work_done_sem;
 	u64			cpu_usage;
 };
 enum sched_event_type {
 	SCHED_EVENT_RUN,
 	SCHED_EVENT_SLEEP,
 	SCHED_EVENT_WAKEUP,
 	SCHED_EVENT_MIGRATION,
 };
 struct sched_atom {
 	enum sched_event_type	type;
 	int			specific_wait;
 	u64			timestamp;
 	u64			duration;
 	unsigned long		nr;
 	sem_t			*wait_sem;
 	struct task_desc	*wakee;
 };
 static struct task_desc		*pid_to_task[MAX_PID];
 static struct task_desc		**tasks;
 static pthread_mutex_t		start_work_mutex = PTHREAD_MUTEX_INITIALIZER;
 static u64			start_time;
 static pthread_mutex_t		work_done_wait_mutex = PTHREAD_MUTEX_INITIALIZER;
 static unsigned long		nr_run_events;
 static unsigned long		nr_sleep_events;
 static unsigned long		nr_wakeup_events;
 static unsigned long		nr_sleep_corrections;
 static unsigned long		nr_run_events_optimized;
 static unsigned long		targetless_wakeups;
 static unsigned long		multitarget_wakeups;
 static u64			cpu_usage;
 static u64			runavg_cpu_usage;
 static u64			parent_cpu_usage;
 static u64			runavg_parent_cpu_usage;
 static unsigned long		nr_runs;
 static u64			sum_runtime;
 static u64			sum_fluct;
 static u64			run_avg;
 static unsigned int		replay_repeat = 10;
 static unsigned long		nr_timestamps;
 static unsigned long		nr_unordered_timestamps;
 static unsigned long		nr_state_machine_bugs;
 static unsigned long		nr_context_switch_bugs;
 static unsigned long		nr_events;
 static unsigned long		nr_lost_chunks;
 static unsigned long		nr_lost_events;
 #define TASK_STATE_TO_CHAR_STR "RSDTtZX"
 enum thread_state {
 	THREAD_SLEEPING = 0,
 	THREAD_WAIT_CPU,
 	THREAD_SCHED_IN,
 	THREAD_IGNORE
 };
 struct work_atom {
 	struct list_head	list;
 	enum thread_state	state;
 	u64			sched_out_time;
 	u64			wake_up_time;
 	u64			sched_in_time;
 	u64			runtime;
 };
 struct work_atoms {
 	struct list_head	work_list;
 	struct thread		*thread;
 	struct rb_node		node;
 	u64			max_lat;
 	u64			max_lat_at;
 	u64			total_lat;
 	u64			nb_atoms;
 	u64			total_runtime;
 };
 typedef int (*sort_fn_t)(struct work_atoms *, struct work_atoms *);
 static struct rb_root		atom_root, sorted_atom_root;
 static u64			all_runtime;
 static u64			all_count;
 static u64 get_nsecs(void)
 {
 	struct timespec ts;
 	clock_gettime(CLOCK_MONOTONIC, &ts);
 	return ts.tv_sec * 1000000000ULL + ts.tv_nsec;
 }
 static void burn_nsecs(u64 nsecs)
 {
 	u64 T0 = get_nsecs(), T1;
 	do {
 		T1 = get_nsecs();
 	} while (T1 + run_measurement_overhead < T0 + nsecs);
 }
 static void sleep_nsecs(u64 nsecs)
 {
 	struct timespec ts;
 	ts.tv_nsec = nsecs % 999999999;
 	ts.tv_sec = nsecs / 999999999;
 	nanosleep(&ts, NULL);
 }
 static void calibrate_run_measurement_overhead(void)
 {
 	u64 T0, T1, delta, min_delta = 1000000000ULL;
 	int i;
 	for (i = 0; i < 10; i++) {
 		T0 = get_nsecs();
 		burn_nsecs(0);
 		T1 = get_nsecs();
 		delta = T1-T0;
 		min_delta = min(min_delta, delta);
 	}
 	run_measurement_overhead = min_delta;
 	printf("run measurement overhead: %" PRIu64 " nsecs\n", min_delta);
 }
 static void calibrate_sleep_measurement_overhead(void)
 {
 	u64 T0, T1, delta, min_delta = 1000000000ULL;
 	int i;
 	for (i = 0; i < 10; i++) {
 		T0 = get_nsecs();
 		sleep_nsecs(10000);
 		T1 = get_nsecs();
 		delta = T1-T0;
 		min_delta = min(min_delta, delta);
 	}
 	min_delta -= 10000;
 	sleep_measurement_overhead = min_delta;
 	printf("sleep measurement overhead: %" PRIu64 " nsecs\n", min_delta);
 }
 static struct sched_atom *
 get_new_event(struct task_desc *task, u64 timestamp)
 {
 	struct sched_atom *event = zalloc(sizeof(*event));
 	unsigned long idx = task->nr_events;
 	size_t size;
 	event->timestamp = timestamp;
 	event->nr = idx;
 	task->nr_events++;
 	size = sizeof(struct sched_atom *) * task->nr_events;
 	task->atoms = realloc(task->atoms, size);
 	BUG_ON(!task->atoms);
 	task->atoms[idx] = event;
 	return event;
 }
 static struct sched_atom *last_event(struct task_desc *task)
 {
 	if (!task->nr_events)
 		return NULL;
 	return task->atoms[task->nr_events - 1];
 }
 static void
 add_sched_event_run(struct task_desc *task, u64 timestamp, u64 duration)
 {
 	struct sched_atom *event, *curr_event = last_event(task);
 	/*
 	 * optimize an existing RUN event by merging this one
 	 * to it:
 	 */
 	if (curr_event && curr_event->type == SCHED_EVENT_RUN) {
 		nr_run_events_optimized++;
 		curr_event->duration += duration;
 		return;
 	}
 	event = get_new_event(task, timestamp);
 	event->type = SCHED_EVENT_RUN;
 	event->duration = duration;
 	nr_run_events++;
 }
 static void
 add_sched_event_wakeup(struct task_desc *task, u64 timestamp,
 		       struct task_desc *wakee)
 {
 	struct sched_atom *event, *wakee_event;
 	event = get_new_event(task, timestamp);
 	event->type = SCHED_EVENT_WAKEUP;
 	event->wakee = wakee;
 	wakee_event = last_event(wakee);
 	if (!wakee_event || wakee_event->type != SCHED_EVENT_SLEEP) {
 		targetless_wakeups++;
 		return;
 	}
 	if (wakee_event->wait_sem) {
 		multitarget_wakeups++;
 		return;
 	}
 	wakee_event->wait_sem = zalloc(sizeof(*wakee_event->wait_sem));
 	sem_init(wakee_event->wait_sem, 0, 0);
 	wakee_event->specific_wait = 1;
 	event->wait_sem = wakee_event->wait_sem;
 	nr_wakeup_events++;
 }
 static void
 add_sched_event_sleep(struct task_desc *task, u64 timestamp,
 		      u64 task_state __used)
 {
 	struct sched_atom *event = get_new_event(task, timestamp);
 	event->type = SCHED_EVENT_SLEEP;
 	nr_sleep_events++;
 }
 static struct task_desc *register_pid(unsigned long pid, const char *comm)
 {
 	struct task_desc *task;
 	BUG_ON(pid >= MAX_PID);
 	task = pid_to_task[pid];
 	if (task)
 		return task;
 	task = zalloc(sizeof(*task));
 	task->pid = pid;
 	task->nr = nr_tasks;
 	strcpy(task->comm, comm);
 	/*
 	 * every task starts in sleeping state - this gets ignored
 	 * if there's no wakeup pointing to this sleep state:
 	 */
 	add_sched_event_sleep(task, 0, 0);
 	pid_to_task[pid] = task;
 	nr_tasks++;
 	tasks = realloc(tasks, nr_tasks*sizeof(struct task_task *));
 	BUG_ON(!tasks);
 	tasks[task->nr] = task;
 	if (verbose)
 		printf("registered task #%ld, PID %ld (%s)\n", nr_tasks, pid, comm);
 	return task;
 }
 static void print_task_traces(void)
 {
 	struct task_desc *task;
 	unsigned long i;
 	for (i = 0; i < nr_tasks; i++) {
 		task = tasks[i];
 		printf("task %6ld (%20s:%10ld), nr_events: %ld\n",
 			task->nr, task->comm, task->pid, task->nr_events);
 	}
 }
 static void add_cross_task_wakeups(void)
 {
 	struct task_desc *task1, *task2;
 	unsigned long i, j;
 	for (i = 0; i < nr_tasks; i++) {
 		task1 = tasks[i];
 		j = i + 1;
 		if (j == nr_tasks)
 			j = 0;
 		task2 = tasks[j];
 		add_sched_event_wakeup(task1, 0, task2);
 	}
 }
 static void
 process_sched_event(struct task_desc *this_task __used, struct sched_atom *atom)
 {
 	int ret = 0;
 	switch (atom->type) {
 		case SCHED_EVENT_RUN:
 			burn_nsecs(atom->duration);
 			break;
 		case SCHED_EVENT_SLEEP:
 			if (atom->wait_sem)
 				ret = sem_wait(atom->wait_sem);
 			BUG_ON(ret);
 			break;
 		case SCHED_EVENT_WAKEUP:
 			if (atom->wait_sem)
 				ret = sem_post(atom->wait_sem);
 			BUG_ON(ret);
 			break;
 		case SCHED_EVENT_MIGRATION:
 			break;
 		default:
 			BUG_ON(1);
 	}
 }
 static u64 get_cpu_usage_nsec_parent(void)
 {
 	struct rusage ru;
 	u64 sum;
 	int err;
 	err = getrusage(RUSAGE_SELF, &ru);
 	BUG_ON(err);
 	sum =  ru.ru_utime.tv_sec*1e9 + ru.ru_utime.tv_usec*1e3;
 	sum += ru.ru_stime.tv_sec*1e9 + ru.ru_stime.tv_usec*1e3;
 	return sum;
 }
 static int self_open_counters(void)
 {
 	struct perf_event_attr attr;
 	int fd;
 	memset(&attr, 0, sizeof(attr));
 	attr.type = PERF_TYPE_SOFTWARE;
 	attr.config = PERF_COUNT_SW_TASK_CLOCK;
 	fd = sys_perf_event_open(&attr, 0, -1, -1, 0);
 	if (fd < 0)
 		die("Error: sys_perf_event_open() syscall returned"
 		    "with %d (%s)\n", fd, strerror(errno));
 	return fd;
 }
 static u64 get_cpu_usage_nsec_self(int fd)
 {
 	u64 runtime;
 	int ret;
 	ret = read(fd, &runtime, sizeof(runtime));
 	BUG_ON(ret != sizeof(runtime));
 	return runtime;
 }
 static void *thread_func(void *ctx)
 {
 	struct task_desc *this_task = ctx;
 	u64 cpu_usage_0, cpu_usage_1;
 	unsigned long i, ret;
 	char comm2[22];
 	int fd;
 	sprintf(comm2, ":%s", this_task->comm);
 	prctl(PR_SET_NAME, comm2);
 	fd = self_open_counters();
 again:
 	ret = sem_post(&this_task->ready_for_work);
 	BUG_ON(ret);
 	ret = pthread_mutex_lock(&start_work_mutex);
 	BUG_ON(ret);
 	ret = pthread_mutex_unlock(&start_work_mutex);
 	BUG_ON(ret);
 	cpu_usage_0 = get_cpu_usage_nsec_self(fd);
 	for (i = 0; i < this_task->nr_events; i++) {
 		this_task->curr_event = i;
 		process_sched_event(this_task, this_task->atoms[i]);
 	}
 	cpu_usage_1 = get_cpu_usage_nsec_self(fd);
 	this_task->cpu_usage = cpu_usage_1 - cpu_usage_0;
 	ret = sem_post(&this_task->work_done_sem);
 	BUG_ON(ret);
 	ret = pthread_mutex_lock(&work_done_wait_mutex);
 	BUG_ON(ret);
 	ret = pthread_mutex_unlock(&work_done_wait_mutex);
 	BUG_ON(ret);
 	goto again;
 }
 static void create_tasks(void)
 {
 	struct task_desc *task;
 	pthread_attr_t attr;
 	unsigned long i;
 	int err;
 	err = pthread_attr_init(&attr);
 	BUG_ON(err);
 	err = pthread_attr_setstacksize(&attr,
 			(size_t) max(16 * 1024, PTHREAD_STACK_MIN));
 	BUG_ON(err);
 	err = pthread_mutex_lock(&start_work_mutex);
 	BUG_ON(err);
 	err = pthread_mutex_lock(&work_done_wait_mutex);
 	BUG_ON(err);
 	for (i = 0; i < nr_tasks; i++) {
 		task = tasks[i];
 		sem_init(&task->sleep_sem, 0, 0);
 		sem_init(&task->ready_for_work, 0, 0);
 		sem_init(&task->work_done_sem, 0, 0);
 		task->curr_event = 0;
 		err = pthread_create(&task->thread, &attr, thread_func, task);
 		BUG_ON(err);
 	}
 }
 static void wait_for_tasks(void)
 {
 	u64 cpu_usage_0, cpu_usage_1;
 	struct task_desc *task;
 	unsigned long i, ret;
 	start_time = get_nsecs();
 	cpu_usage = 0;
 	pthread_mutex_unlock(&work_done_wait_mutex);
 	for (i = 0; i < nr_tasks; i++) {
 		task = tasks[i];
 		ret = sem_wait(&task->ready_for_work);
 		BUG_ON(ret);
 		sem_init(&task->ready_for_work, 0, 0);
 	}
 	ret = pthread_mutex_lock(&work_done_wait_mutex);
 	BUG_ON(ret);
 	cpu_usage_0 = get_cpu_usage_nsec_parent();
 	pthread_mutex_unlock(&start_work_mutex);
 	for (i = 0; i < nr_tasks; i++) {
 		task = tasks[i];
 		ret = sem_wait(&task->work_done_sem);
 		BUG_ON(ret);
 		sem_init(&task->work_done_sem, 0, 0);
 		cpu_usage += task->cpu_usage;
 		task->cpu_usage = 0;
 	}
 	cpu_usage_1 = get_cpu_usage_nsec_parent();
 	if (!runavg_cpu_usage)
 		runavg_cpu_usage = cpu_usage;
 	runavg_cpu_usage = (runavg_cpu_usage*9 + cpu_usage)/10;
 	parent_cpu_usage = cpu_usage_1 - cpu_usage_0;
 	if (!runavg_parent_cpu_usage)
 		runavg_parent_cpu_usage = parent_cpu_usage;
 	runavg_parent_cpu_usage = (runavg_parent_cpu_usage*9 +
 				   parent_cpu_usage)/10;
 	ret = pthread_mutex_lock(&start_work_mutex);
 	BUG_ON(ret);
 	for (i = 0; i < nr_tasks; i++) {
 		task = tasks[i];
 		sem_init(&task->sleep_sem, 0, 0);
 		task->curr_event = 0;
 	}
 }
 static void run_one_test(void)
 {
 	u64 T0, T1, delta, avg_delta, fluct;
 	T0 = get_nsecs();
 	wait_for_tasks();
 	T1 = get_nsecs();
 	delta = T1 - T0;
 	sum_runtime += delta;
 	nr_runs++;
 	avg_delta = sum_runtime / nr_runs;
 	if (delta < avg_delta)
 		fluct = avg_delta - delta;
 	else
 		fluct = delta - avg_delta;
 	sum_fluct += fluct;
 	if (!run_avg)
 		run_avg = delta;
 	run_avg = (run_avg*9 + delta)/10;
 	printf("#%-3ld: %0.3f, ",
 		nr_runs, (double)delta/1000000.0);
 	printf("ravg: %0.2f, ",
 		(double)run_avg/1e6);
 	printf("cpu: %0.2f / %0.2f",
 		(double)cpu_usage/1e6, (double)runavg_cpu_usage/1e6);
 #if 0
 	/*
 	 * rusage statistics done by the parent, these are less
 	 * accurate than the sum_exec_runtime based statistics:
 	 */
 	printf(" [%0.2f / %0.2f]",
 		(double)parent_cpu_usage/1e6,
 		(double)runavg_parent_cpu_usage/1e6);
 #endif
 	printf("\n");
 	if (nr_sleep_corrections)
 		printf(" (%ld sleep corrections)\n", nr_sleep_corrections);
 	nr_sleep_corrections = 0;
 }
 static void test_calibrations(void)
 {
 	u64 T0, T1;
 	T0 = get_nsecs();
 	burn_nsecs(1e6);
 	T1 = get_nsecs();
 	printf("the run test took %" PRIu64 " nsecs\n", T1 - T0);
 	T0 = get_nsecs();
 	sleep_nsecs(1e6);
 	T1 = get_nsecs();
 	printf("the sleep test took %" PRIu64 " nsecs\n", T1 - T0);
 }
 #define FILL_FIELD(ptr, field, event, data)	\
 	ptr.field = (typeof(ptr.field)) raw_field_value(event, #field, data)
 #define FILL_ARRAY(ptr, array, event, data)			\
 do {								\
 	void *__array = raw_field_ptr(event, #array, data);	\
 	memcpy(ptr.array, __array, sizeof(ptr.array));	\
 } while(0)
 #define FILL_COMMON_FIELDS(ptr, event, data)			\
 do {								\
 	FILL_FIELD(ptr, common_type, event, data);		\
 	FILL_FIELD(ptr, common_flags, event, data);		\
 	FILL_FIELD(ptr, common_preempt_count, event, data);	\
 	FILL_FIELD(ptr, common_pid, event, data);		\
 	FILL_FIELD(ptr, common_tgid, event, data);		\
 } while (0)
 struct trace_switch_event {
 	u32 size;
 	u16 common_type;
 	u8 common_flags;
 	u8 common_preempt_count;
 	u32 common_pid;
 	u32 common_tgid;
 	char prev_comm[16];
 	u32 prev_pid;
 	u32 prev_prio;
 	u64 prev_state;
 	char next_comm[16];
 	u32 next_pid;
 	u32 next_prio;
 };
 struct trace_runtime_event {
 	u32 size;
 	u16 common_type;
 	u8 common_flags;
 	u8 common_preempt_count;
 	u32 common_pid;
 	u32 common_tgid;
 	char comm[16];
 	u32 pid;
 	u64 runtime;
 	u64 vruntime;
 };
 struct trace_wakeup_event {
 	u32 size;
 	u16 common_type;
 	u8 common_flags;
 	u8 common_preempt_count;
 	u32 common_pid;
 	u32 common_tgid;
 	char comm[16];
 	u32 pid;
 	u32 prio;
 	u32 success;
 	u32 cpu;
 };
 struct trace_fork_event {
 	u32 size;
 	u16 common_type;
 	u8 common_flags;
 	u8 common_preempt_count;
 	u32 common_pid;
 	u32 common_tgid;
 	char parent_comm[16];
 	u32 parent_pid;
 	char child_comm[16];
 	u32 child_pid;
 };
 struct trace_migrate_task_event {
 	u32 size;
 	u16 common_type;
 	u8 common_flags;
 	u8 common_preempt_count;
 	u32 common_pid;
 	u32 common_tgid;
 	char comm[16];
 	u32 pid;
 	u32 prio;
 	u32 cpu;
 };
 struct trace_sched_handler {
 	void (*switch_event)(struct trace_switch_event *,
 			     struct perf_session *,
 			     struct event *,
 			     int cpu,
 			     u64 timestamp,
 			     struct thread *thread);
 	void (*runtime_event)(struct trace_runtime_event *,
 			      struct perf_session *,
 			      struct event *,
 			      int cpu,
 			      u64 timestamp,
 			      struct thread *thread);
 	void (*wakeup_event)(struct trace_wakeup_event *,
 			     struct perf_session *,
 			     struct event *,
 			     int cpu,
 			     u64 timestamp,
 			     struct thread *thread);
 	void (*fork_event)(struct trace_fork_event *,
 			   struct event *,
 			   int cpu,
 			   u64 timestamp,
 			   struct thread *thread);
 	void (*migrate_task_event)(struct trace_migrate_task_event *,
 			   struct perf_session *session,
 			   struct event *,
 			   int cpu,
 			   u64 timestamp,
 			   struct thread *thread);
 };
 static void
 replay_wakeup_event(struct trace_wakeup_event *wakeup_event,
 		    struct perf_session *session __used,
 		    struct event *event,
 		    int cpu __used,
 		    u64 timestamp __used,
 		    struct thread *thread __used)
 {
 	struct task_desc *waker, *wakee;
 	if (verbose) {
 		printf("sched_wakeup event %p\n", event);
 		printf(" ... pid %d woke up %s/%d\n",
 			wakeup_event->common_pid,
 			wakeup_event->comm,
 			wakeup_event->pid);
 	}
 	waker = register_pid(wakeup_event->common_pid, "<unknown>");
 	wakee = register_pid(wakeup_event->pid, wakeup_event->comm);
 	add_sched_event_wakeup(waker, timestamp, wakee);
 }
 static u64 cpu_last_switched[MAX_CPUS];
 static void
 replay_switch_event(struct trace_switch_event *switch_event,
 		    struct perf_session *session __used,
 		    struct event *event,
 		    int cpu,
 		    u64 timestamp,
 		    struct thread *thread __used)
 {
 	struct task_desc *prev, __used *next;
 	u64 timestamp0;
 	s64 delta;
 	if (verbose)
 		printf("sched_switch event %p\n", event);
 	if (cpu >= MAX_CPUS || cpu < 0)
 		return;
 	timestamp0 = cpu_last_switched[cpu];
 	if (timestamp0)
 		delta = timestamp - timestamp0;
 	else
 		delta = 0;
 	if (delta < 0)
 		die("hm, delta: %" PRIu64 " < 0 ?\n", delta);
 	if (verbose) {
 		printf(" ... switch from %s/%d to %s/%d [ran %" PRIu64 " nsecs]\n",
 			switch_event->prev_comm, switch_event->prev_pid,
 			switch_event->next_comm, switch_event->next_pid,
 			delta);
 	}
 	prev = register_pid(switch_event->prev_pid, switch_event->prev_comm);
 	next = register_pid(switch_event->next_pid, switch_event->next_comm);
 	cpu_last_switched[cpu] = timestamp;
 	add_sched_event_run(prev, timestamp, delta);
 	add_sched_event_sleep(prev, timestamp, switch_event->prev_state);
 }
 static void
 replay_fork_event(struct trace_fork_event *fork_event,
 		  struct event *event,
 		  int cpu __used,
 		  u64 timestamp __used,
 		  struct thread *thread __used)
 {
 	if (verbose) {
 		printf("sched_fork event %p\n", event);
 		printf("... parent: %s/%d\n", fork_event->parent_comm, fork_event->parent_pid);
 		printf("...  child: %s/%d\n", fork_event->child_comm, fork_event->child_pid);
 	}
 	register_pid(fork_event->parent_pid, fork_event->parent_comm);
 	register_pid(fork_event->child_pid, fork_event->child_comm);
 }
 static struct trace_sched_handler replay_ops  = {
 	.wakeup_event		= replay_wakeup_event,
 	.switch_event		= replay_switch_event,
 	.fork_event		= replay_fork_event,
 };
 struct sort_dimension {
 	const char		*name;
 	sort_fn_t		cmp;
 	struct list_head	list;
 };
 static LIST_HEAD(cmp_pid);
 static int
 thread_lat_cmp(struct list_head *list, struct work_atoms *l, struct work_atoms *r)
 {
 	struct sort_dimension *sort;
 	int ret = 0;
 	BUG_ON(list_empty(list));
 	list_for_each_entry(sort, list, list) {
 		ret = sort->cmp(l, r);
 		if (ret)
 			return ret;
 	}
 	return ret;
 }
 static struct work_atoms *
 thread_atoms_search(struct rb_root *root, struct thread *thread,
 			 struct list_head *sort_list)
 {
 	struct rb_node *node = root->rb_node;
 	struct work_atoms key = { .thread = thread };
 	while (node) {
 		struct work_atoms *atoms;
 		int cmp;
 		atoms = container_of(node, struct work_atoms, node);
 		cmp = thread_lat_cmp(sort_list, &key, atoms);
 		if (cmp > 0)
 			node = node->rb_left;
 		else if (cmp < 0)
 			node = node->rb_right;
 		else {
 			BUG_ON(thread != atoms->thread);
 			return atoms;
 		}
 	}
 	return NULL;
 }
 static void
 __thread_latency_insert(struct rb_root *root, struct work_atoms *data,
 			 struct list_head *sort_list)
 {
 	struct rb_node **new = &(root->rb_node), *parent = NULL;
 	while (*new) {
 		struct work_atoms *this;
 		int cmp;
 		this = container_of(*new, struct work_atoms, node);
 		parent = *new;
 		cmp = thread_lat_cmp(sort_list, data, this);
 		if (cmp > 0)
 			new = &((*new)->rb_left);
 		else
 			new = &((*new)->rb_right);
 	}
 	rb_link_node(&data->node, parent, new);
 	rb_insert_color(&data->node, root);
 }
 static void thread_atoms_insert(struct thread *thread)
 {
 	struct work_atoms *atoms = zalloc(sizeof(*atoms));
 	if (!atoms)
 		die("No memory");
 	atoms->thread = thread;
 	INIT_LIST_HEAD(&atoms->work_list);
 	__thread_latency_insert(&atom_root, atoms, &cmp_pid);
 }
 static void
 latency_fork_event(struct trace_fork_event *fork_event __used,
 		   struct event *event __used,
 		   int cpu __used,
 		   u64 timestamp __used,
 		   struct thread *thread __used)
 {
 	/* should insert the newcomer */
 }
 __used
 static char sched_out_state(struct trace_switch_event *switch_event)
 {
 	const char *str = TASK_STATE_TO_CHAR_STR;
 	return str[switch_event->prev_state];
 }
 static void
 add_sched_out_event(struct work_atoms *atoms,
 		    char run_state,
 		    u64 timestamp)
 {
 	struct work_atom *atom = zalloc(sizeof(*atom));
 	if (!atom)
 		die("Non memory");
 	atom->sched_out_time = timestamp;
 	if (run_state == 'R') {
 		atom->state = THREAD_WAIT_CPU;
 		atom->wake_up_time = atom->sched_out_time;
 	}
 	list_add_tail(&atom->list, &atoms->work_list);
 }
 static void
 add_runtime_event(struct work_atoms *atoms, u64 delta, u64 timestamp __used)
 {
 	struct work_atom *atom;
 	BUG_ON(list_empty(&atoms->work_list));
 	atom = list_entry(atoms->work_list.prev, struct work_atom, list);
 	atom->runtime += delta;
 	atoms->total_runtime += delta;
 }
 static void
 add_sched_in_event(struct work_atoms *atoms, u64 timestamp)
 {
 	struct work_atom *atom;
 	u64 delta;
 	if (list_empty(&atoms->work_list))
 		return;
 	atom = list_entry(atoms->work_list.prev, struct work_atom, list);
 	if (atom->state != THREAD_WAIT_CPU)
 		return;
 	if (timestamp < atom->wake_up_time) {
 		atom->state = THREAD_IGNORE;
 		return;
 	}
 	atom->state = THREAD_SCHED_IN;
 	atom->sched_in_time = timestamp;
 	delta = atom->sched_in_time - atom->wake_up_time;
 	atoms->total_lat += delta;
 	if (delta > atoms->max_lat) {
 		atoms->max_lat = delta;
 		atoms->max_lat_at = timestamp;
 	}
 	atoms->nb_atoms++;
 }
 static void
 latency_switch_event(struct trace_switch_event *switch_event,
 		     struct perf_session *session,
 		     struct event *event __used,
 		     int cpu,
 		     u64 timestamp,
 		     struct thread *thread __used)
 {
 	struct work_atoms *out_events, *in_events;
 	struct thread *sched_out, *sched_in;
 	u64 timestamp0;
 	s64 delta;
 	BUG_ON(cpu >= MAX_CPUS || cpu < 0);
 	timestamp0 = cpu_last_switched[cpu];
 	cpu_last_switched[cpu] = timestamp;
 	if (timestamp0)
 		delta = timestamp - timestamp0;
 	else
 		delta = 0;
 	if (delta < 0)
 		die("hm, delta: %" PRIu64 " < 0 ?\n", delta);
 	sched_out = perf_session__findnew(session, switch_event->prev_pid);
 	sched_in = perf_session__findnew(session, switch_event->next_pid);
 	out_events = thread_atoms_search(&atom_root, sched_out, &cmp_pid);
 	if (!out_events) {
 		thread_atoms_insert(sched_out);
 		out_events = thread_atoms_search(&atom_root, sched_out, &cmp_pid);
 		if (!out_events)
 			die("out-event: Internal tree error");
 	}
 	add_sched_out_event(out_events, sched_out_state(switch_event), timestamp);
 	in_events = thread_atoms_search(&atom_root, sched_in, &cmp_pid);
 	if (!in_events) {
 		thread_atoms_insert(sched_in);
 		in_events = thread_atoms_search(&atom_root, sched_in, &cmp_pid);
 		if (!in_events)
 			die("in-event: Internal tree error");
 		/*
 		 * Take came in we have not heard about yet,
 		 * add in an initial atom in runnable state:
 		 */
 		add_sched_out_event(in_events, 'R', timestamp);
 	}
 	add_sched_in_event(in_events, timestamp);
 }
 static void
 latency_runtime_event(struct trace_runtime_event *runtime_event,
 		     struct perf_session *session,
 		     struct event *event __used,
 		     int cpu,
 		     u64 timestamp,
 		     struct thread *this_thread __used)
 {
 	struct thread *thread = perf_session__findnew(session, runtime_event->pid);
 	struct work_atoms *atoms = thread_atoms_search(&atom_root, thread, &cmp_pid);
 	BUG_ON(cpu >= MAX_CPUS || cpu < 0);
 	if (!atoms) {
 		thread_atoms_insert(thread);
 		atoms = thread_atoms_search(&atom_root, thread, &cmp_pid);
 		if (!atoms)
 			die("in-event: Internal tree error");
 		add_sched_out_event(atoms, 'R', timestamp);
 	}
 	add_runtime_event(atoms, runtime_event->runtime, timestamp);
 }
 static void
 latency_wakeup_event(struct trace_wakeup_event *wakeup_event,
 		     struct perf_session *session,
 		     struct event *__event __used,
 		     int cpu __used,
 		     u64 timestamp,
 		     struct thread *thread __used)
 {
 	struct work_atoms *atoms;
 	struct work_atom *atom;
 	struct thread *wakee;
 	/* Note for later, it may be interesting to observe the failing cases */
 	if (!wakeup_event->success)
 		return;
 	wakee = perf_session__findnew(session, wakeup_event->pid);
 	atoms = thread_atoms_search(&atom_root, wakee, &cmp_pid);
 	if (!atoms) {
 		thread_atoms_insert(wakee);
 		atoms = thread_atoms_search(&atom_root, wakee, &cmp_pid);
 		if (!atoms)
 			die("wakeup-event: Internal tree error");
 		add_sched_out_event(atoms, 'S', timestamp);
 	}
 	BUG_ON(list_empty(&atoms->work_list));
 	atom = list_entry(atoms->work_list.prev, struct work_atom, list);
 	/*
 	 * You WILL be missing events if you've recorded only
 	 * one CPU, or are only looking at only one, so don't
 	 * make useless noise.
 	 */
 	if (profile_cpu == -1 && atom->state != THREAD_SLEEPING)
 		nr_state_machine_bugs++;
 	nr_timestamps++;
 	if (atom->sched_out_time > timestamp) {
 		nr_unordered_timestamps++;
 		return;
 	}
 	atom->state = THREAD_WAIT_CPU;
 	atom->wake_up_time = timestamp;
 }
 static void
 latency_migrate_task_event(struct trace_migrate_task_event *migrate_task_event,
 		     struct perf_session *session,
 		     struct event *__event __used,
 		     int cpu __used,
 		     u64 timestamp,
 		     struct thread *thread __used)
 {
 	struct work_atoms *atoms;
 	struct work_atom *atom;
 	struct thread *migrant;
 	/*
 	 * Only need to worry about migration when profiling one CPU.
 	 */
 	if (profile_cpu == -1)
 		return;
 	migrant = perf_session__findnew(session, migrate_task_event->pid);
 	atoms = thread_atoms_search(&atom_root, migrant, &cmp_pid);
 	if (!atoms) {
 		thread_atoms_insert(migrant);
 		register_pid(migrant->pid, migrant->comm);
 		atoms = thread_atoms_search(&atom_root, migrant, &cmp_pid);
 		if (!atoms)
 			die("migration-event: Internal tree error");
 		add_sched_out_event(atoms, 'R', timestamp);
 	}
 	BUG_ON(list_empty(&atoms->work_list));
 	atom = list_entry(atoms->work_list.prev, struct work_atom, list);
 	atom->sched_in_time = atom->sched_out_time = atom->wake_up_time = timestamp;
 	nr_timestamps++;
 	if (atom->sched_out_time > timestamp)
 		nr_unordered_timestamps++;
 }
 static struct trace_sched_handler lat_ops  = {
 	.wakeup_event		= latency_wakeup_event,
 	.switch_event		= latency_switch_event,
 	.runtime_event		= latency_runtime_event,
 	.fork_event		= latency_fork_event,
 	.migrate_task_event	= latency_migrate_task_event,
 };
 static void output_lat_thread(struct work_atoms *work_list)
 {
 	int i;
 	int ret;
 	u64 avg;
 	if (!work_list->nb_atoms)
 		return;
 	/*
 	 * Ignore idle threads:
 	 */
 	if (!strcmp(work_list->thread->comm, "swapper"))
 		return;
 	all_runtime += work_list->total_runtime;
 	all_count += work_list->nb_atoms;
 	ret = printf("  %s:%d ", work_list->thread->comm, work_list->thread->pid);
 	for (i = 0; i < 24 - ret; i++)
 		printf(" ");
 	avg = work_list->total_lat / work_list->nb_atoms;
 	printf("|%11.3f ms |%9" PRIu64 " | avg:%9.3f ms | max:%9.3f ms | max at: %9.6f s\n",
 	      (double)work_list->total_runtime / 1e6,
 		 work_list->nb_atoms, (double)avg / 1e6,
 		 (double)work_list->max_lat / 1e6,
 		 (double)work_list->max_lat_at / 1e9);
 }
 static int pid_cmp(struct work_atoms *l, struct work_atoms *r)
 {
 	if (l->thread->pid < r->thread->pid)
 		return -1;
 	if (l->thread->pid > r->thread->pid)
 		return 1;
 	return 0;
 }
 static struct sort_dimension pid_sort_dimension = {
 	.name			= "pid",
 	.cmp			= pid_cmp,
 };
 static int avg_cmp(struct work_atoms *l, struct work_atoms *r)
 {
 	u64 avgl, avgr;
 	if (!l->nb_atoms)
 		return -1;
 	if (!r->nb_atoms)
 		return 1;
 	avgl = l->total_lat / l->nb_atoms;
 	avgr = r->total_lat / r->nb_atoms;
 	if (avgl < avgr)
 		return -1;
 	if (avgl > avgr)
 		return 1;
 	return 0;
 }
 static struct sort_dimension avg_sort_dimension = {
 	.name			= "avg",
 	.cmp			= avg_cmp,
 };
 static int max_cmp(struct work_atoms *l, struct work_atoms *r)
 {
 	if (l->max_lat < r->max_lat)
 		return -1;
 	if (l->max_lat > r->max_lat)
 		return 1;
 	return 0;
 }
 static struct sort_dimension max_sort_dimension = {
 	.name			= "max",
 	.cmp			= max_cmp,
 };
 static int switch_cmp(struct work_atoms *l, struct work_atoms *r)
 {
 	if (l->nb_atoms < r->nb_atoms)
 		return -1;
 	if (l->nb_atoms > r->nb_atoms)
 		return 1;
 	return 0;
 }
 static struct sort_dimension switch_sort_dimension = {
 	.name			= "switch",
 	.cmp			= switch_cmp,
 };
 static int runtime_cmp(struct work_atoms *l, struct work_atoms *r)
 {
 	if (l->total_runtime < r->total_runtime)
 		return -1;
 	if (l->total_runtime > r->total_runtime)
 		return 1;
 	return 0;
 }
 static struct sort_dimension runtime_sort_dimension = {
 	.name			= "runtime",
 	.cmp			= runtime_cmp,
 };
 static struct sort_dimension *available_sorts[] = {
 	&pid_sort_dimension,
 	&avg_sort_dimension,
 	&max_sort_dimension,
 	&switch_sort_dimension,
 	&runtime_sort_dimension,
 };
 #define NB_AVAILABLE_SORTS	(int)(sizeof(available_sorts) / sizeof(struct sort_dimension *))
 static LIST_HEAD(sort_list);
 static int sort_dimension__add(const char *tok, struct list_head *list)
 {
 	int i;
 	for (i = 0; i < NB_AVAILABLE_SORTS; i++) {
 		if (!strcmp(available_sorts[i]->name, tok)) {
 			list_add_tail(&available_sorts[i]->list, list);
 			return 0;
 		}
 	}
 	return -1;
 }
 static void setup_sorting(void);
 static void sort_lat(void)
 {
 	struct rb_node *node;
 	for (;;) {
 		struct work_atoms *data;
 		node = rb_first(&atom_root);
 		if (!node)
 			break;
 		rb_erase(node, &atom_root);
 		data = rb_entry(node, struct work_atoms, node);
 		__thread_latency_insert(&sorted_atom_root, data, &sort_list);
 	}
 }
 static struct trace_sched_handler *trace_handler;
 static void
 process_sched_wakeup_event(void *data, struct perf_session *session,
 			   struct event *event,
 			   int cpu __used,
 			   u64 timestamp __used,
 			   struct thread *thread __used)
 {
 	struct trace_wakeup_event wakeup_event;
 	FILL_COMMON_FIELDS(wakeup_event, event, data);
 	FILL_ARRAY(wakeup_event, comm, event, data);
 	FILL_FIELD(wakeup_event, pid, event, data);
 	FILL_FIELD(wakeup_event, prio, event, data);
 	FILL_FIELD(wakeup_event, success, event, data);
 	FILL_FIELD(wakeup_event, cpu, event, data);
 	if (trace_handler->wakeup_event)
 		trace_handler->wakeup_event(&wakeup_event, session, event,
 					    cpu, timestamp, thread);
 }
 /*
  * Track the current task - that way we can know whether there's any
  * weird events, such as a task being switched away that is not current.
  */
 static int max_cpu;
 static u32 curr_pid[MAX_CPUS] = { [0 ... MAX_CPUS-1] = -1 };
 static struct thread *curr_thread[MAX_CPUS];
 static char next_shortname1 = 'A';
 static char next_shortname2 = '0';
 static void
 map_switch_event(struct trace_switch_event *switch_event,
 		 struct perf_session *session,
 		 struct event *event __used,
 		 int this_cpu,
 		 u64 timestamp,
 		 struct thread *thread __used)
 {
 	struct thread *sched_out __used, *sched_in;
 	int new_shortname;
 	u64 timestamp0;
 	s64 delta;
 	int cpu;
 	BUG_ON(this_cpu >= MAX_CPUS || this_cpu < 0);
 	if (this_cpu > max_cpu)
 		max_cpu = this_cpu;
 	timestamp0 = cpu_last_switched[this_cpu];
 	cpu_last_switched[this_cpu] = timestamp;
 	if (timestamp0)
 		delta = timestamp - timestamp0;
 	else
 		delta = 0;
 	if (delta < 0)
 		die("hm, delta: %" PRIu64 " < 0 ?\n", delta);
 	sched_out = perf_session__findnew(session, switch_event->prev_pid);
 	sched_in = perf_session__findnew(session, switch_event->next_pid);
 	curr_thread[this_cpu] = sched_in;
 	printf("  ");
 	new_shortname = 0;
 	if (!sched_in->shortname[0]) {
 		sched_in->shortname[0] = next_shortname1;
 		sched_in->shortname[1] = next_shortname2;
 		if (next_shortname1 < 'Z') {
 			next_shortname1++;
 		} else {
 			next_shortname1='A';
 			if (next_shortname2 < '9') {
 				next_shortname2++;
 			} else {
 				next_shortname2='0';
 			}
 		}
 		new_shortname = 1;
 	}
 	for (cpu = 0; cpu <= max_cpu; cpu++) {
 		if (cpu != this_cpu)
 			printf(" ");
 		else
 			printf("*");
 		if (curr_thread[cpu]) {
 			if (curr_thread[cpu]->pid)
 				printf("%2s ", curr_thread[cpu]->shortname);
 			else
 				printf(".  ");
 		} else
 			printf("   ");
 	}
 	printf("  %12.6f secs ", (double)timestamp/1e9);
 	if (new_shortname) {
 		printf("%s => %s:%d\n",
 			sched_in->shortname, sched_in->comm, sched_in->pid);
 	} else {
 		printf("\n");
 	}
 }
 static void
 process_sched_switch_event(void *data, struct perf_session *session,
 			   struct event *event,
 			   int this_cpu,
 			   u64 timestamp __used,
 			   struct thread *thread __used)
 {
 	struct trace_switch_event switch_event;
 	FILL_COMMON_FIELDS(switch_event, event, data);
 	FILL_ARRAY(switch_event, prev_comm, event, data);
 	FILL_FIELD(switch_event, prev_pid, event, data);
 	FILL_FIELD(switch_event, prev_prio, event, data);
 	FILL_FIELD(switch_event, prev_state, event, data);
 	FILL_ARRAY(switch_event, next_comm, event, data);
 	FILL_FIELD(switch_event, next_pid, event, data);
 	FILL_FIELD(switch_event, next_prio, event, data);
 	if (curr_pid[this_cpu] != (u32)-1) {
 		/*
 		 * Are we trying to switch away a PID that is
 		 * not current?
 		 */
 		if (curr_pid[this_cpu] != switch_event.prev_pid)
 			nr_context_switch_bugs++;
 	}
 	if (trace_handler->switch_event)
 		trace_handler->switch_event(&switch_event, session, event,
 					    this_cpu, timestamp, thread);
 	curr_pid[this_cpu] = switch_event.next_pid;
 }
 static void
 process_sched_runtime_event(void *data, struct perf_session *session,
 			   struct event *event,
 			   int cpu __used,
 			   u64 timestamp __used,
 			   struct thread *thread __used)
 {
 	struct trace_runtime_event runtime_event;
 	FILL_ARRAY(runtime_event, comm, event, data);
 	FILL_FIELD(runtime_event, pid, event, data);
 	FILL_FIELD(runtime_event, runtime, event, data);
 	FILL_FIELD(runtime_event, vruntime, event, data);
 	if (trace_handler->runtime_event)
 		trace_handler->runtime_event(&runtime_event, session, event, cpu, timestamp, thread);
 }
 static void
 process_sched_fork_event(void *data,
 			 struct event *event,
 			 int cpu __used,
 			 u64 timestamp __used,
 			 struct thread *thread __used)
 {
 	struct trace_fork_event fork_event;
 	FILL_COMMON_FIELDS(fork_event, event, data);
 	FILL_ARRAY(fork_event, parent_comm, event, data);
 	FILL_FIELD(fork_event, parent_pid, event, data);
 	FILL_ARRAY(fork_event, child_comm, event, data);
 	FILL_FIELD(fork_event, child_pid, event, data);
 	if (trace_handler->fork_event)
 		trace_handler->fork_event(&fork_event, event,
 					  cpu, timestamp, thread);
 }
 static void
 process_sched_exit_event(struct event *event,
 			 int cpu __used,
 			 u64 timestamp __used,
 			 struct thread *thread __used)
 {
 	if (verbose)
 		printf("sched_exit event %p\n", event);
 }
 static void
 process_sched_migrate_task_event(void *data, struct perf_session *session,
 			   struct event *event,
 			   int cpu __used,
 			   u64 timestamp __used,
 			   struct thread *thread __used)
 {
 	struct trace_migrate_task_event migrate_task_event;
 	FILL_COMMON_FIELDS(migrate_task_event, event, data);
 	FILL_ARRAY(migrate_task_event, comm, event, data);
 	FILL_FIELD(migrate_task_event, pid, event, data);
 	FILL_FIELD(migrate_task_event, prio, event, data);
 	FILL_FIELD(migrate_task_event, cpu, event, data);
 	if (trace_handler->migrate_task_event)
 		trace_handler->migrate_task_event(&migrate_task_event, session,
 						 event, cpu, timestamp, thread);
 }
 static void process_raw_event(union perf_event *raw_event __used,
 			      struct perf_session *session, void *data, int cpu,
 			      u64 timestamp, struct thread *thread)
 {
 	struct event *event;
 	int type;
 	type = trace_parse_common_type(data);
 	event = trace_find_event(type);
 	if (!strcmp(event->name, "sched_switch"))
 		process_sched_switch_event(data, session, event, cpu, timestamp, thread);
 	if (!strcmp(event->name, "sched_stat_runtime"))
 		process_sched_runtime_event(data, session, event, cpu, timestamp, thread);
 	if (!strcmp(event->name, "sched_wakeup"))
 		process_sched_wakeup_event(data, session, event, cpu, timestamp, thread);
 	if (!strcmp(event->name, "sched_wakeup_new"))
 		process_sched_wakeup_event(data, session, event, cpu, timestamp, thread);
 	if (!strcmp(event->name, "sched_process_fork"))
 		process_sched_fork_event(data, event, cpu, timestamp, thread);
 	if (!strcmp(event->name, "sched_process_exit"))
 		process_sched_exit_event(event, cpu, timestamp, thread);
 	if (!strcmp(event->name, "sched_migrate_task"))
 		process_sched_migrate_task_event(data, session, event, cpu, timestamp, thread);
 }
 static int process_sample_event(union perf_event *event,
 				struct perf_sample *sample,
 				struct perf_evsel *evsel __used,
 				struct perf_session *session)
 {
 	struct thread *thread;
 	if (!(session->sample_type & PERF_SAMPLE_RAW))
 		return 0;
 	thread = perf_session__findnew(session, sample->pid);
 	if (thread == NULL) {
 		pr_debug("problem processing %d event, skipping it.\n",
 			 event->header.type);
 		return -1;
 	}
 	dump_printf(" ... thread: %s:%d\n", thread->comm, thread->pid);
 	if (profile_cpu != -1 && profile_cpu != (int)sample->cpu)
 		return 0;
 	process_raw_event(event, session, sample->raw_data, sample->cpu,
 			  sample->time, thread);
 	return 0;
 }
 static struct perf_event_ops event_ops = {
 	.sample			= process_sample_event,
 	.comm			= perf_event__process_comm,
 	.lost			= perf_event__process_lost,
 	.fork			= perf_event__process_task,
 	.ordered_samples	= true,
 };
-static int read_events(void)
+static void read_events(bool destroy, struct perf_session **psession)
 {
 	int err = -EINVAL;
 	struct perf_session *session = perf_session__new(input_name, O_RDONLY,
 							 0, false, &event_ops);
 	if (session == NULL)
-		return -ENOMEM;
+		die("No Memory");
 	if (perf_session__has_traces(session, "record -R")) {
 		err = perf_session__process_events(session, &event_ops);
+		if (err)
+			die("Failed to process events, error %d", err);
 		nr_events      = session->hists.stats.nr_events[0];
 		nr_lost_events = session->hists.stats.total_lost;
 		nr_lost_chunks = session->hists.stats.nr_events[PERF_RECORD_LOST];
 	}
-	perf_session__delete(session);
+	if (destroy)
-	return err;
+		perf_session__delete(session);
+	if (psession)
+		*psession = session;
 }
 static void print_bad_events(void)
 {
 	if (nr_unordered_timestamps && nr_timestamps) {
 		printf("  INFO: %.3f%% unordered timestamps (%ld out of %ld)\n",
 			(double)nr_unordered_timestamps/(double)nr_timestamps*100.0,
 			nr_unordered_timestamps, nr_timestamps);
 	}
 	if (nr_lost_events && nr_events) {
 		printf("  INFO: %.3f%% lost events (%ld out of %ld, in %ld chunks)\n",
 			(double)nr_lost_events/(double)nr_events*100.0,
 			nr_lost_events, nr_events, nr_lost_chunks);
 	}
 	if (nr_state_machine_bugs && nr_timestamps) {
 		printf("  INFO: %.3f%% state machine bugs (%ld out of %ld)",
 			(double)nr_state_machine_bugs/(double)nr_timestamps*100.0,
 			nr_state_machine_bugs, nr_timestamps);
 		if (nr_lost_events)
 			printf(" (due to lost events?)");
 		printf("\n");
 	}
 	if (nr_context_switch_bugs && nr_timestamps) {
 		printf("  INFO: %.3f%% context switch bugs (%ld out of %ld)",
 			(double)nr_context_switch_bugs/(double)nr_timestamps*100.0,
 			nr_context_switch_bugs, nr_timestamps);
 		if (nr_lost_events)
 			printf(" (due to lost events?)");
 		printf("\n");
 	}
 }
 static void __cmd_lat(void)
 {
 	struct rb_node *next;
+	struct perf_session *session;
 	setup_pager();
-	read_events();
+	read_events(false, &session);
 	sort_lat();
 	printf("\n ---------------------------------------------------------------------------------------------------------------\n");
 	printf("  Task                  |   Runtime ms  | Switches | Average delay ms | Maximum delay ms | Maximum delay at     |\n");
 	printf(" ---------------------------------------------------------------------------------------------------------------\n");
 	next = rb_first(&sorted_atom_root);
 	while (next) {
 		struct work_atoms *work_list;
 		work_list = rb_entry(next, struct work_atoms, node);
 		output_lat_thread(work_list);
 		next = rb_next(next);
 	}
 	printf(" -----------------------------------------------------------------------------------------\n");
 	printf("  TOTAL:                |%11.3f ms |%9" PRIu64 " |\n",
 		(double)all_runtime/1e6, all_count);
 	printf(" ---------------------------------------------------\n");
 	print_bad_events();
 	printf("\n");
+	perf_session__delete(session);
 }
 static struct trace_sched_handler map_ops  = {
 	.wakeup_event		= NULL,
 	.switch_event		= map_switch_event,
 	.runtime_event		= NULL,
 	.fork_event		= NULL,
 };
 static void __cmd_map(void)
 {
 	max_cpu = sysconf(_SC_NPROCESSORS_CONF);
 	setup_pager();
-	read_events();
+	read_events(true, NULL);
 	print_bad_events();
 }
 static void __cmd_replay(void)
 {
 	unsigned long i;
 	calibrate_run_measurement_overhead();
 	calibrate_sleep_measurement_overhead();
 	test_calibrations();
-	read_events();
+	read_events(true, NULL);
 	printf("nr_run_events:        %ld\n", nr_run_events);
 	printf("nr_sleep_events:      %ld\n", nr_sleep_events);
 	printf("nr_wakeup_events:     %ld\n", nr_wakeup_events);
 	if (targetless_wakeups)
 		printf("target-less wakeups:  %ld\n", targetless_wakeups);
 	if (multitarget_wakeups)
 		printf("multi-target wakeups: %ld\n", multitarget_wakeups);
 	if (nr_run_events_optimized)
 		printf("run atoms optimized: %ld\n",
 			nr_run_events_optimized);
 	print_task_traces();
 	add_cross_task_wakeups();
 	create_tasks();
 	printf("------------------------------------------------------------\n");
 	for (i = 0; i < replay_repeat; i++)
 		run_one_test();
 }
 static const char * const sched_usage[] = {
-	"perf sched [<options>] {record|latency|map|replay|trace}",
+	"perf sched [<options>] {record|latency|map|replay|script}",
 	NULL
 };
 static const struct option sched_options[] = {
 	OPT_STRING('i', "input", &input_name, "file",
 		    "input file name"),
 	OPT_INCR('v', "verbose", &verbose,
 		    "be more verbose (show symbol address, etc)"),
 	OPT_BOOLEAN('D', "dump-raw-trace", &dump_trace,
 		    "dump raw trace in ASCII"),
 	OPT_END()
 };
 static const char * const latency_usage[] = {
 	"perf sched latency [<options>]",
 	NULL
 };
 static const struct option latency_options[] = {
 	OPT_STRING('s', "sort", &sort_order, "key[,key2...]",
 		   "sort by key(s): runtime, switch, avg, max"),
 	OPT_INCR('v', "verbose", &verbose,
 		    "be more verbose (show symbol address, etc)"),
 	OPT_INTEGER('C', "CPU", &profile_cpu,
 		    "CPU to profile on"),
 	OPT_BOOLEAN('D', "dump-raw-trace", &dump_trace,
 		    "dump raw trace in ASCII"),
 	OPT_END()
 };
 static const char * const replay_usage[] = {
 	"perf sched replay [<options>]",
 	NULL
 };
 static const struct option replay_options[] = {
 	OPT_UINTEGER('r', "repeat", &replay_repeat,
 		     "repeat the workload replay N times (-1: infinite)"),
 	OPT_INCR('v', "verbose", &verbose,
 		    "be more verbose (show symbol address, etc)"),
 	OPT_BOOLEAN('D', "dump-raw-trace", &dump_trace,
 		    "dump raw trace in ASCII"),
 	OPT_END()
 };
 static void setup_sorting(void)
 {
 	char *tmp, *tok, *str = strdup(sort_order);
 	for (tok = strtok_r(str, ", ", &tmp);
 			tok; tok = strtok_r(NULL, ", ", &tmp)) {
 		if (sort_dimension__add(tok, &sort_list) < 0) {
 			error("Unknown --sort key: `%s'", tok);
 			usage_with_options(latency_usage, latency_options);
 		}
 	}
 	free(str);
 	sort_dimension__add("pid", &cmp_pid);
 }
 static const char *record_args[] = {
 	"record",
 	"-a",
 	"-R",
 	"-f",
 	"-m", "1024",
 	"-c", "1",
 	"-e", "sched:sched_switch",
 	"-e", "sched:sched_stat_wait",
 	"-e", "sched:sched_stat_sleep",
 	"-e", "sched:sched_stat_iowait",
 	"-e", "sched:sched_stat_runtime",
 	"-e", "sched:sched_process_exit",
 	"-e", "sched:sched_process_fork",
 	"-e", "sched:sched_wakeup",
 	"-e", "sched:sched_migrate_task",
 };
 static int __cmd_record(int argc, const char **argv)
 {
 	unsigned int rec_argc, i, j;
 	const char **rec_argv;
 	rec_argc = ARRAY_SIZE(record_args) + argc - 1;
 	rec_argv = calloc(rec_argc + 1, sizeof(char *));
 	if (rec_argv == NULL)
 		return -ENOMEM;
 	for (i = 0; i < ARRAY_SIZE(record_args); i++)
 		rec_argv[i] = strdup(record_args[i]);
 	for (j = 1; j < (unsigned int)argc; j++, i++)
 		rec_argv[i] = argv[j];
 	BUG_ON(i != rec_argc);
 	return cmd_record(i, rec_argv, NULL);
 }
 int cmd_sched(int argc, const char **argv, const char *prefix __used)
 {
 	argc = parse_options(argc, argv, sched_options, sched_usage,
 			     PARSE_OPT_STOP_AT_NON_OPTION);
 	if (!argc)
 		usage_with_options(sched_usage, sched_options);
 	/*
 	 * Aliased to 'perf script' for now:
 	 */
 	if (!strcmp(argv[0], "script"))
 		return cmd_script(argc, argv, prefix);
 	symbol__init();
 	if (!strncmp(argv[0], "rec", 3)) {
 		return __cmd_record(argc, argv);
 	} else if (!strncmp(argv[0], "lat", 3)) {
 		trace_handler = &lat_ops;
 		if (argc > 1) {
 			argc = parse_options(argc, argv, latency_options, latency_usage, 0);
 			if (argc)
 				usage_with_options(latency_usage, latency_options);
 		}
 		setup_sorting();
 		__cmd_lat();
 	} else if (!strcmp(argv[0], "map")) {
 		trace_handler = &map_ops;
 		setup_sorting();
 		__cmd_map();
 	} else if (!strncmp(argv[0], "rep", 3)) {
 		trace_handler = &replay_ops;
 		if (argc) {
 			argc = parse_options(argc, argv, replay_options, replay_usage, 0);
 			if (argc)
 				usage_with_options(replay_usage, replay_options);
 		}
 		__cmd_replay();
 	} else {
 		usage_with_options(sched_usage, sched_options);
 	}
 	return 0;
 }

tools/perf/util/config.c

Diff comments View file @ 1d229d5

1	/*	1	/*
2	* GIT - The information manager from hell	2	* GIT - The information manager from hell
3	*	3	*
4	* Copyright (C) Linus Torvalds, 2005	4	* Copyright (C) Linus Torvalds, 2005
5	* Copyright (C) Johannes Schindelin, 2005	5	* Copyright (C) Johannes Schindelin, 2005
6	*	6	*
7	*/	7	*/
8	#include "util.h"	8	#include "util.h"
9	#include "cache.h"	9	#include "cache.h"
10	#include "exec_cmd.h"	10	#include "exec_cmd.h"
11		11
12	#define MAXNAME (256)	12	#define MAXNAME (256)
13		13
14	#define DEBUG_CACHE_DIR ".debug"	14	#define DEBUG_CACHE_DIR ".debug"
15		15
16		16
17	char buildid_dir[MAXPATHLEN]; /* root dir for buildid, binary cache */	17	char buildid_dir[MAXPATHLEN]; /* root dir for buildid, binary cache */
18		18
19	static FILE *config_file;	19	static FILE *config_file;
20	static const char *config_file_name;	20	static const char *config_file_name;
21	static int config_linenr;	21	static int config_linenr;
22	static int config_file_eof;	22	static int config_file_eof;
23		23
24	static const char *config_exclusive_filename;	24	static const char *config_exclusive_filename;
25		25
26	static int get_next_char(void)	26	static int get_next_char(void)
27	{	27	{
28	int c;	28	int c;
29	FILE *f;	29	FILE *f;
30		30
31	c = '\n';	31	c = '\n';
32	if ((f = config_file) != NULL) {	32	if ((f = config_file) != NULL) {
33	c = fgetc(f);	33	c = fgetc(f);
34	if (c == '\r') {	34	if (c == '\r') {
35	/* DOS like systems */	35	/* DOS like systems */
36	c = fgetc(f);	36	c = fgetc(f);
37	if (c != '\n') {	37	if (c != '\n') {
38	ungetc(c, f);	38	ungetc(c, f);
39	c = '\r';	39	c = '\r';
40	}	40	}
41	}	41	}
42	if (c == '\n')	42	if (c == '\n')
43	config_linenr++;	43	config_linenr++;
44	if (c == EOF) {	44	if (c == EOF) {
45	config_file_eof = 1;	45	config_file_eof = 1;
46	c = '\n';	46	c = '\n';
47	}	47	}
48	}	48	}
49	return c;	49	return c;
50	}	50	}
51		51
52	static char *parse_value(void)	52	static char *parse_value(void)
53	{	53	{
54	static char value[1024];	54	static char value[1024];
55	int quote = 0, comment = 0, space = 0;	55	int quote = 0, comment = 0, space = 0;
56	size_t len = 0;	56	size_t len = 0;
57		57
58	for (;;) {	58	for (;;) {
59	int c = get_next_char();	59	int c = get_next_char();
60		60
61	if (len >= sizeof(value) - 1)	61	if (len >= sizeof(value) - 1)
62	return NULL;	62	return NULL;
63	if (c == '\n') {	63	if (c == '\n') {
64	if (quote)	64	if (quote)
65	return NULL;	65	return NULL;
66	value[len] = 0;	66	value[len] = 0;
67	return value;	67	return value;
68	}	68	}
69	if (comment)	69	if (comment)
70	continue;	70	continue;
71	if (isspace(c) && !quote) {	71	if (isspace(c) && !quote) {
72	space = 1;	72	space = 1;
73	continue;	73	continue;
74	}	74	}
75	if (!quote) {	75	if (!quote) {
76	if (c == ';' \|\| c == '#') {	76	if (c == ';' \|\| c == '#') {
77	comment = 1;	77	comment = 1;
78	continue;	78	continue;
79	}	79	}
80	}	80	}
81	if (space) {	81	if (space) {
82	if (len)	82	if (len)
83	value[len++] = ' ';	83	value[len++] = ' ';
84	space = 0;	84	space = 0;
85	}	85	}
86	if (c == '\\') {	86	if (c == '\\') {
87	c = get_next_char();	87	c = get_next_char();
88	switch (c) {	88	switch (c) {
89	case '\n':	89	case '\n':
90	continue;	90	continue;
91	case 't':	91	case 't':
92	c = '\t';	92	c = '\t';
93	break;	93	break;
94	case 'b':	94	case 'b':
95	c = '\b';	95	c = '\b';
96	break;	96	break;
97	case 'n':	97	case 'n':
98	c = '\n';	98	c = '\n';
99	break;	99	break;
100	/* Some characters escape as themselves */	100	/* Some characters escape as themselves */
101	case '\\': case '"':	101	case '\\': case '"':
102	break;	102	break;
103	/* Reject unknown escape sequences */	103	/* Reject unknown escape sequences */
104	default:	104	default:
105	return NULL;	105	return NULL;
106	}	106	}
107	value[len++] = c;	107	value[len++] = c;
108	continue;	108	continue;
109	}	109	}
110	if (c == '"') {	110	if (c == '"') {
111	quote = 1-quote;	111	quote = 1-quote;
112	continue;	112	continue;
113	}	113	}
114	value[len++] = c;	114	value[len++] = c;
115	}	115	}
116	}	116	}
117		117
118	static inline int iskeychar(int c)	118	static inline int iskeychar(int c)
119	{	119	{
120	return isalnum(c) \|\| c == '-';	120	return isalnum(c) \|\| c == '-';
121	}	121	}
122		122
123	static int get_value(config_fn_t fn, void data, char name, unsigned int len)	123	static int get_value(config_fn_t fn, void data, char name, unsigned int len)
124	{	124	{
125	int c;	125	int c;
126	char *value;	126	char *value;
127		127
128	/* Get the full name */	128	/* Get the full name */
129	for (;;) {	129	for (;;) {
130	c = get_next_char();	130	c = get_next_char();
131	if (config_file_eof)	131	if (config_file_eof)
132	break;	132	break;
133	if (!iskeychar(c))	133	if (!iskeychar(c))
134	break;	134	break;
135	name[len++] = c;	135	name[len++] = c;
136	if (len >= MAXNAME)	136	if (len >= MAXNAME)
137	return -1;	137	return -1;
138	}	138	}
139	name[len] = 0;	139	name[len] = 0;
140	while (c == ' ' \|\| c == '\t')	140	while (c == ' ' \|\| c == '\t')
141	c = get_next_char();	141	c = get_next_char();
142		142
143	value = NULL;	143	value = NULL;
144	if (c != '\n') {	144	if (c != '\n') {
145	if (c != '=')	145	if (c != '=')
146	return -1;	146	return -1;
147	value = parse_value();	147	value = parse_value();
148	if (!value)	148	if (!value)
149	return -1;	149	return -1;
150	}	150	}
151	return fn(name, value, data);	151	return fn(name, value, data);
152	}	152	}
153		153
154	static int get_extended_base_var(char *name, int baselen, int c)	154	static int get_extended_base_var(char *name, int baselen, int c)
155	{	155	{
156	do {	156	do {
157	if (c == '\n')	157	if (c == '\n')
158	return -1;	158	return -1;
159	c = get_next_char();	159	c = get_next_char();
160	} while (isspace(c));	160	} while (isspace(c));
161		161
162	/* We require the format to be '[base "extension"]' */	162	/* We require the format to be '[base "extension"]' */
163	if (c != '"')	163	if (c != '"')
164	return -1;	164	return -1;
165	name[baselen++] = '.';	165	name[baselen++] = '.';
166		166
167	for (;;) {	167	for (;;) {
168	int ch = get_next_char();	168	int ch = get_next_char();
169		169
170	if (ch == '\n')	170	if (ch == '\n')
171	return -1;	171	return -1;
172	if (ch == '"')	172	if (ch == '"')
173	break;	173	break;
174	if (ch == '\\') {	174	if (ch == '\\') {
175	ch = get_next_char();	175	ch = get_next_char();
176	if (ch == '\n')	176	if (ch == '\n')
177	return -1;	177	return -1;
178	}	178	}
179	name[baselen++] = ch;	179	name[baselen++] = ch;
180	if (baselen > MAXNAME / 2)	180	if (baselen > MAXNAME / 2)
181	return -1;	181	return -1;
182	}	182	}
183		183
184	/* Final ']' */	184	/* Final ']' */
185	if (get_next_char() != ']')	185	if (get_next_char() != ']')
186	return -1;	186	return -1;
187	return baselen;	187	return baselen;
188	}	188	}
189		189
190	static int get_base_var(char *name)	190	static int get_base_var(char *name)
191	{	191	{
192	int baselen = 0;	192	int baselen = 0;
193		193
194	for (;;) {	194	for (;;) {
195	int c = get_next_char();	195	int c = get_next_char();
196	if (config_file_eof)	196	if (config_file_eof)
197	return -1;	197	return -1;
198	if (c == ']')	198	if (c == ']')
199	return baselen;	199	return baselen;
200	if (isspace(c))	200	if (isspace(c))
201	return get_extended_base_var(name, baselen, c);	201	return get_extended_base_var(name, baselen, c);
202	if (!iskeychar(c) && c != '.')	202	if (!iskeychar(c) && c != '.')
203	return -1;	203	return -1;
204	if (baselen > MAXNAME / 2)	204	if (baselen > MAXNAME / 2)
205	return -1;	205	return -1;
206	name[baselen++] = tolower(c);	206	name[baselen++] = tolower(c);
207	}	207	}
208	}	208	}
209		209
210	static int perf_parse_file(config_fn_t fn, void *data)	210	static int perf_parse_file(config_fn_t fn, void *data)
211	{	211	{
212	int comment = 0;	212	int comment = 0;
213	int baselen = 0;	213	int baselen = 0;
214	static char var[MAXNAME];	214	static char var[MAXNAME];
215		215
216	/* U+FEFF Byte Order Mark in UTF8 */	216	/* U+FEFF Byte Order Mark in UTF8 */
217	static const unsigned char utf8_bom = (unsigned char ) "\xef\xbb\xbf";	217	static const unsigned char utf8_bom = (unsigned char ) "\xef\xbb\xbf";
218	const unsigned char *bomptr = utf8_bom;	218	const unsigned char *bomptr = utf8_bom;
219		219
220	for (;;) {	220	for (;;) {
221	int c = get_next_char();	221	int c = get_next_char();
222	if (bomptr && *bomptr) {	222	if (bomptr && *bomptr) {
223	/* We are at the file beginning; skip UTF8-encoded BOM	223	/* We are at the file beginning; skip UTF8-encoded BOM
224	* if present. Sane editors won't put this in on their	224	* if present. Sane editors won't put this in on their
225	* own, but e.g. Windows Notepad will do it happily. */	225	* own, but e.g. Windows Notepad will do it happily. */
226	if ((unsigned char) c == *bomptr) {	226	if ((unsigned char) c == *bomptr) {
227	bomptr++;	227	bomptr++;
228	continue;	228	continue;
229	} else {	229	} else {
230	/* Do not tolerate partial BOM. */	230	/* Do not tolerate partial BOM. */
231	if (bomptr != utf8_bom)	231	if (bomptr != utf8_bom)
232	break;	232	break;
233	/* No BOM at file beginning. Cool. */	233	/* No BOM at file beginning. Cool. */
234	bomptr = NULL;	234	bomptr = NULL;
235	}	235	}
236	}	236	}
237	if (c == '\n') {	237	if (c == '\n') {
238	if (config_file_eof)	238	if (config_file_eof)
239	return 0;	239	return 0;
240	comment = 0;	240	comment = 0;
241	continue;	241	continue;
242	}	242	}
243	if (comment \|\| isspace(c))	243	if (comment \|\| isspace(c))
244	continue;	244	continue;
245	if (c == '#' \|\| c == ';') {	245	if (c == '#' \|\| c == ';') {
246	comment = 1;	246	comment = 1;
247	continue;	247	continue;
248	}	248	}
249	if (c == '[') {	249	if (c == '[') {
250	baselen = get_base_var(var);	250	baselen = get_base_var(var);
251	if (baselen <= 0)	251	if (baselen <= 0)
252	break;	252	break;
253	var[baselen++] = '.';	253	var[baselen++] = '.';
254	var[baselen] = 0;	254	var[baselen] = 0;
255	continue;	255	continue;
256	}	256	}
257	if (!isalpha(c))	257	if (!isalpha(c))
258	break;	258	break;
259	var[baselen] = tolower(c);	259	var[baselen] = tolower(c);
260	if (get_value(fn, data, var, baselen+1) < 0)	260	if (get_value(fn, data, var, baselen+1) < 0)
261	break;	261	break;
262	}	262	}
263	die("bad config file line %d in %s", config_linenr, config_file_name);	263	die("bad config file line %d in %s", config_linenr, config_file_name);
264	}	264	}
265		265
266	static int parse_unit_factor(const char end, unsigned long val)	266	static int parse_unit_factor(const char end, unsigned long val)
267	{	267	{
268	if (!*end)	268	if (!*end)
269	return 1;	269	return 1;
270	else if (!strcasecmp(end, "k")) {	270	else if (!strcasecmp(end, "k")) {
271	val = 1024;	271	val = 1024;
272	return 1;	272	return 1;
273	}	273	}
274	else if (!strcasecmp(end, "m")) {	274	else if (!strcasecmp(end, "m")) {
275	val = 1024 * 1024;	275	val = 1024 * 1024;
276	return 1;	276	return 1;
277	}	277	}
278	else if (!strcasecmp(end, "g")) {	278	else if (!strcasecmp(end, "g")) {
279	val = 1024 * 1024 * 1024;	279	val = 1024 * 1024 * 1024;
280	return 1;	280	return 1;
281	}	281	}
282	return 0;	282	return 0;
283	}	283	}
284		284
285	static int perf_parse_long(const char value, long ret)	285	static int perf_parse_long(const char value, long ret)
286	{	286	{
287	if (value && *value) {	287	if (value && *value) {
288	char *end;	288	char *end;
289	long val = strtol(value, &end, 0);	289	long val = strtol(value, &end, 0);
290	unsigned long factor = 1;	290	unsigned long factor = 1;
291	if (!parse_unit_factor(end, &factor))	291	if (!parse_unit_factor(end, &factor))
292	return 0;	292	return 0;
293	ret = val factor;	293	ret = val factor;
294	return 1;	294	return 1;
295	}	295	}
296	return 0;	296	return 0;
297	}	297	}
298		298
299	static void die_bad_config(const char *name)	299	static void die_bad_config(const char *name)
300	{	300	{
301	if (config_file_name)	301	if (config_file_name)
302	die("bad config value for '%s' in %s", name, config_file_name);	302	die("bad config value for '%s' in %s", name, config_file_name);
303	die("bad config value for '%s'", name);	303	die("bad config value for '%s'", name);
304	}	304	}
305		305
306	int perf_config_int(const char name, const char value)	306	int perf_config_int(const char name, const char value)
307	{	307	{
308	long ret = 0;	308	long ret = 0;
309	if (!perf_parse_long(value, &ret))	309	if (!perf_parse_long(value, &ret))
310	die_bad_config(name);	310	die_bad_config(name);
311	return ret;	311	return ret;
312	}	312	}
313		313
314	static int perf_config_bool_or_int(const char name, const char value, int *is_bool)	314	static int perf_config_bool_or_int(const char name, const char value, int *is_bool)
315	{	315	{
316	*is_bool = 1;	316	*is_bool = 1;
317	if (!value)	317	if (!value)
318	return 1;	318	return 1;
319	if (!*value)	319	if (!*value)
320	return 0;	320	return 0;
321	if (!strcasecmp(value, "true") \|\| !strcasecmp(value, "yes") \|\| !strcasecmp(value, "on"))	321	if (!strcasecmp(value, "true") \|\| !strcasecmp(value, "yes") \|\| !strcasecmp(value, "on"))
322	return 1;	322	return 1;
323	if (!strcasecmp(value, "false") \|\| !strcasecmp(value, "no") \|\| !strcasecmp(value, "off"))	323	if (!strcasecmp(value, "false") \|\| !strcasecmp(value, "no") \|\| !strcasecmp(value, "off"))
324	return 0;	324	return 0;
325	*is_bool = 0;	325	*is_bool = 0;
326	return perf_config_int(name, value);	326	return perf_config_int(name, value);
327	}	327	}
328		328
329	int perf_config_bool(const char name, const char value)	329	int perf_config_bool(const char name, const char value)
330	{	330	{
331	int discard;	331	int discard;
332	return !!perf_config_bool_or_int(name, value, &discard);	332	return !!perf_config_bool_or_int(name, value, &discard);
333	}	333	}
334		334
335	const char perf_config_dirname(const char name, const char *value)	335	const char perf_config_dirname(const char name, const char *value)
336	{	336	{
337	if (!name)	337	if (!name)
338	return NULL;	338	return NULL;
339	return value;	339	return value;
340	}	340	}
341		341
342	static int perf_default_core_config(const char var __used, const char value __used)	342	static int perf_default_core_config(const char var __used, const char value __used)
343	{	343	{
344	/* Add other config variables here and to Documentation/config.txt. */	344	/* Add other config variables here and to Documentation/config.txt. */
345	return 0;	345	return 0;
346	}	346	}
347		347
348	int perf_default_config(const char var, const char value, void *dummy __used)	348	int perf_default_config(const char var, const char value, void *dummy __used)
349	{	349	{
350	if (!prefixcmp(var, "core."))	350	if (!prefixcmp(var, "core."))
351	return perf_default_core_config(var, value);	351	return perf_default_core_config(var, value);
352		352
353	/* Add other config variables here and to Documentation/config.txt. */	353	/* Add other config variables here and to Documentation/config.txt. */
354	return 0;	354	return 0;
355	}	355	}
356		356
357	static int perf_config_from_file(config_fn_t fn, const char filename, void data)	357	static int perf_config_from_file(config_fn_t fn, const char filename, void data)
358	{	358	{
359	int ret;	359	int ret;
360	FILE *f = fopen(filename, "r");	360	FILE *f = fopen(filename, "r");
361		361
362	ret = -1;	362	ret = -1;
363	if (f) {	363	if (f) {
364	config_file = f;	364	config_file = f;
365	config_file_name = filename;	365	config_file_name = filename;
366	config_linenr = 1;	366	config_linenr = 1;
367	config_file_eof = 0;	367	config_file_eof = 0;
368	ret = perf_parse_file(fn, data);	368	ret = perf_parse_file(fn, data);
369	fclose(f);	369	fclose(f);
370	config_file_name = NULL;	370	config_file_name = NULL;
371	}	371	}
372	return ret;	372	return ret;
373	}	373	}
374		374
375	static const char *perf_etc_perfconfig(void)	375	static const char *perf_etc_perfconfig(void)
376	{	376	{
377	static const char *system_wide;	377	static const char *system_wide;
378	if (!system_wide)	378	if (!system_wide)
379	system_wide = system_path(ETC_PERFCONFIG);	379	system_wide = system_path(ETC_PERFCONFIG);
380	return system_wide;	380	return system_wide;
381	}	381	}
382		382
383	static int perf_env_bool(const char *k, int def)	383	static int perf_env_bool(const char *k, int def)
384	{	384	{
385	const char *v = getenv(k);	385	const char *v = getenv(k);
386	return v ? perf_config_bool(k, v) : def;	386	return v ? perf_config_bool(k, v) : def;
387	}	387	}
388		388
389	static int perf_config_system(void)	389	static int perf_config_system(void)
390	{	390	{
391	return !perf_env_bool("PERF_CONFIG_NOSYSTEM", 0);	391	return !perf_env_bool("PERF_CONFIG_NOSYSTEM", 0);
392	}	392	}
393		393
394	static int perf_config_global(void)	394	static int perf_config_global(void)
395	{	395	{
396	return !perf_env_bool("PERF_CONFIG_NOGLOBAL", 0);	396	return !perf_env_bool("PERF_CONFIG_NOGLOBAL", 0);
397	}	397	}
398		398
399	int perf_config(config_fn_t fn, void *data)	399	int perf_config(config_fn_t fn, void *data)
400	{	400	{
401	int ret = 0, found = 0;	401	int ret = 0, found = 0;
402	char *repo_config = NULL;
403	const char *home = NULL;	402	const char *home = NULL;
404		403
405	/* Setting $PERF_CONFIG makes perf read _only_ the given config file. */	404	/* Setting $PERF_CONFIG makes perf read _only_ the given config file. */
406	if (config_exclusive_filename)	405	if (config_exclusive_filename)
407	return perf_config_from_file(fn, config_exclusive_filename, data);	406	return perf_config_from_file(fn, config_exclusive_filename, data);
408	if (perf_config_system() && !access(perf_etc_perfconfig(), R_OK)) {	407	if (perf_config_system() && !access(perf_etc_perfconfig(), R_OK)) {
409	ret += perf_config_from_file(fn, perf_etc_perfconfig(),	408	ret += perf_config_from_file(fn, perf_etc_perfconfig(),
410	data);	409	data);
411	found += 1;	410	found += 1;
412	}	411	}
413		412
414	home = getenv("HOME");	413	home = getenv("HOME");
415	if (perf_config_global() && home) {	414	if (perf_config_global() && home) {
416	char *user_config = strdup(mkpath("%s/.perfconfig", home));	415	char *user_config = strdup(mkpath("%s/.perfconfig", home));
417	if (!access(user_config, R_OK)) {	416	struct stat st;
418	ret += perf_config_from_file(fn, user_config, data);	417
419	found += 1;	418	if (user_config == NULL) {
		419	warning("Not enough memory to process %s/.perfconfig, "
		420	"ignoring it.", home);
		421	goto out;
420	}	422	}
421	free(user_config);
422	}
423		423
424	repo_config = perf_pathdup("config");	424	if (stat(user_config, &st) < 0)
425	if (!access(repo_config, R_OK)) {	425	goto out_free;
426	ret += perf_config_from_file(fn, repo_config, data);	426
		427	if (st.st_uid && (st.st_uid != geteuid())) {
		428	warning("File %s not owned by current user or root, "
		429	"ignoring it.", user_config);
		430	goto out_free;
		431	}
		432
		433	if (!st.st_size)
		434	goto out_free;
		435
		436	ret += perf_config_from_file(fn, user_config, data);
427	found += 1;	437	found += 1;
		438	out_free:
		439	free(user_config);
428	}	440	}
429	free(repo_config);	441	out:
430	if (found == 0)	442	if (found == 0)
431	return -1;	443	return -1;
432	return ret;	444	return ret;
433	}	445	}
434		446
435	/*	447	/*
436	* Call this to report error for your variable that should not	448	* Call this to report error for your variable that should not
437	* get a boolean value (i.e. "[my] var" means "true").	449	* get a boolean value (i.e. "[my] var" means "true").
438	*/	450	*/
439	int config_error_nonbool(const char *var)	451	int config_error_nonbool(const char *var)
440	{	452	{
441	return error("Missing value for '%s'", var);	453	return error("Missing value for '%s'", var);
442	}	454	}
443		455
444	struct buildid_dir_config {	456	struct buildid_dir_config {
445	char *dir;	457	char *dir;
446	};	458	};
447		459
448	static int buildid_dir_command_config(const char var, const char value,	460	static int buildid_dir_command_config(const char var, const char value,
449	void *data)	461	void *data)
450	{	462	{
451	struct buildid_dir_config *c = data;	463	struct buildid_dir_config *c = data;
452	const char *v;	464	const char *v;
453		465
454	/* same dir for all commands */	466	/* same dir for all commands */
455	if (!prefixcmp(var, "buildid.") && !strcmp(var + 8, "dir")) {	467	if (!prefixcmp(var, "buildid.") && !strcmp(var + 8, "dir")) {
456	v = perf_config_dirname(var, value);	468	v = perf_config_dirname(var, value);
457	if (!v)	469	if (!v)
458	return -1;	470	return -1;
459	strncpy(c->dir, v, MAXPATHLEN-1);	471	strncpy(c->dir, v, MAXPATHLEN-1);
460	c->dir[MAXPATHLEN-1] = '\0';	472	c->dir[MAXPATHLEN-1] = '\0';
461	}	473	}
462	return 0;	474	return 0;
463	}	475	}
464		476
465	static void check_buildid_dir_config(void)	477	static void check_buildid_dir_config(void)
466	{	478	{
467	struct buildid_dir_config c;	479	struct buildid_dir_config c;
468	c.dir = buildid_dir;	480	c.dir = buildid_dir;
469	perf_config(buildid_dir_command_config, &c);	481	perf_config(buildid_dir_command_config, &c);
470	}	482	}
471		483
472	void set_buildid_dir(void)	484	void set_buildid_dir(void)
473	{	485	{
474	buildid_dir[0] = '\0';	486	buildid_dir[0] = '\0';
475		487
476	/* try config file */	488	/* try config file */
477	check_buildid_dir_config();	489	check_buildid_dir_config();
478		490
479	/* default to $HOME/.debug */	491	/* default to $HOME/.debug */
480	if (buildid_dir[0] == '\0') {	492	if (buildid_dir[0] == '\0') {
481	char *v = getenv("HOME");	493	char *v = getenv("HOME");
482	if (v) {	494	if (v) {
483	snprintf(buildid_dir, MAXPATHLEN-1, "%s/%s",	495	snprintf(buildid_dir, MAXPATHLEN-1, "%s/%s",
484	v, DEBUG_CACHE_DIR);	496	v, DEBUG_CACHE_DIR);
485	} else {	497	} else {
486	strncpy(buildid_dir, DEBUG_CACHE_DIR, MAXPATHLEN-1);	498	strncpy(buildid_dir, DEBUG_CACHE_DIR, MAXPATHLEN-1);
487	}	499	}
488	buildid_dir[MAXPATHLEN-1] = '\0';	500	buildid_dir[MAXPATHLEN-1] = '\0';
489	}	501	}
490	/* for communicating with external commands */	502	/* for communicating with external commands */

tools/perf/util/evlist.c

Diff comments View file @ 1d229d5

 /*
  * Copyright (C) 2011, Red Hat Inc, Arnaldo Carvalho de Melo <acme@redhat.com>
  *
  * Parts came from builtin-{top,stat,record}.c, see those files for further
  * copyright notes.
  *
  * Released under the GPL v2. (and only v2, not any later version)
  */
 #include <poll.h>
 #include "cpumap.h"
 #include "thread_map.h"
 #include "evlist.h"
 #include "evsel.h"
 #include "util.h"
 #include <sys/mman.h>
 #include <linux/bitops.h>
 #include <linux/hash.h>
 #define FD(e, x, y) (*(int *)xyarray__entry(e->fd, x, y))
 #define SID(e, x, y) xyarray__entry(e->sample_id, x, y)
 void perf_evlist__init(struct perf_evlist *evlist, struct cpu_map *cpus,
 		       struct thread_map *threads)
 {
 	int i;
 	for (i = 0; i < PERF_EVLIST__HLIST_SIZE; ++i)
 		INIT_HLIST_HEAD(&evlist->heads[i]);
 	INIT_LIST_HEAD(&evlist->entries);
 	perf_evlist__set_maps(evlist, cpus, threads);
 }
 struct perf_evlist *perf_evlist__new(struct cpu_map *cpus,
 				     struct thread_map *threads)
 {
 	struct perf_evlist *evlist = zalloc(sizeof(*evlist));
 	if (evlist != NULL)
 		perf_evlist__init(evlist, cpus, threads);
 	return evlist;
 }
 static void perf_evlist__purge(struct perf_evlist *evlist)
 {
 	struct perf_evsel *pos, *n;
 	list_for_each_entry_safe(pos, n, &evlist->entries, node) {
 		list_del_init(&pos->node);
 		perf_evsel__delete(pos);
 	}
 	evlist->nr_entries = 0;
 }
 void perf_evlist__exit(struct perf_evlist *evlist)
 {
 	free(evlist->mmap);
 	free(evlist->pollfd);
 	evlist->mmap = NULL;
 	evlist->pollfd = NULL;
 }
 void perf_evlist__delete(struct perf_evlist *evlist)
 {
 	perf_evlist__purge(evlist);
 	perf_evlist__exit(evlist);
 	free(evlist);
 }
 void perf_evlist__add(struct perf_evlist *evlist, struct perf_evsel *entry)
 {
 	list_add_tail(&entry->node, &evlist->entries);
 	++evlist->nr_entries;
 }
 int perf_evlist__add_default(struct perf_evlist *evlist)
 {
 	struct perf_event_attr attr = {
 		.type = PERF_TYPE_HARDWARE,
 		.config = PERF_COUNT_HW_CPU_CYCLES,
 	};
 	struct perf_evsel *evsel = perf_evsel__new(&attr, 0);
 	if (evsel == NULL)
 		return -ENOMEM;
 	perf_evlist__add(evlist, evsel);
 	return 0;
 }
+void perf_evlist__disable(struct perf_evlist *evlist)
+{
+	int cpu, thread;
+	struct perf_evsel *pos;
+	for (cpu = 0; cpu < evlist->cpus->nr; cpu++) {
+		list_for_each_entry(pos, &evlist->entries, node) {
+			for (thread = 0; thread < evlist->threads->nr; thread++)
+				ioctl(FD(pos, cpu, thread), PERF_EVENT_IOC_DISABLE);
+		}
+	}
+}
 int perf_evlist__alloc_pollfd(struct perf_evlist *evlist)
 {
 	int nfds = evlist->cpus->nr * evlist->threads->nr * evlist->nr_entries;
 	evlist->pollfd = malloc(sizeof(struct pollfd) * nfds);
 	return evlist->pollfd != NULL ? 0 : -ENOMEM;
 }
 void perf_evlist__add_pollfd(struct perf_evlist *evlist, int fd)
 {
 	fcntl(fd, F_SETFL, O_NONBLOCK);
 	evlist->pollfd[evlist->nr_fds].fd = fd;
 	evlist->pollfd[evlist->nr_fds].events = POLLIN;
 	evlist->nr_fds++;
 }
 static void perf_evlist__id_hash(struct perf_evlist *evlist,
 				 struct perf_evsel *evsel,
 				 int cpu, int thread, u64 id)
 {
 	int hash;
 	struct perf_sample_id *sid = SID(evsel, cpu, thread);
 	sid->id = id;
 	sid->evsel = evsel;
 	hash = hash_64(sid->id, PERF_EVLIST__HLIST_BITS);
 	hlist_add_head(&sid->node, &evlist->heads[hash]);
 }
 void perf_evlist__id_add(struct perf_evlist *evlist, struct perf_evsel *evsel,
 			 int cpu, int thread, u64 id)
 {
 	perf_evlist__id_hash(evlist, evsel, cpu, thread, id);
 	evsel->id[evsel->ids++] = id;
 }
 static int perf_evlist__id_add_fd(struct perf_evlist *evlist,
 				  struct perf_evsel *evsel,
 				  int cpu, int thread, int fd)
 {
 	u64 read_data[4] = { 0, };
 	int id_idx = 1; /* The first entry is the counter value */
 	if (!(evsel->attr.read_format & PERF_FORMAT_ID) ||
 	    read(fd, &read_data, sizeof(read_data)) == -1)
 		return -1;
 	if (evsel->attr.read_format & PERF_FORMAT_TOTAL_TIME_ENABLED)
 		++id_idx;
 	if (evsel->attr.read_format & PERF_FORMAT_TOTAL_TIME_RUNNING)
 		++id_idx;
 	perf_evlist__id_add(evlist, evsel, cpu, thread, read_data[id_idx]);
 	return 0;
 }
 struct perf_evsel *perf_evlist__id2evsel(struct perf_evlist *evlist, u64 id)
 {
 	struct hlist_head *head;
 	struct hlist_node *pos;
 	struct perf_sample_id *sid;
 	int hash;
 	if (evlist->nr_entries == 1)
 		return list_entry(evlist->entries.next, struct perf_evsel, node);
 	hash = hash_64(id, PERF_EVLIST__HLIST_BITS);
 	head = &evlist->heads[hash];
 	hlist_for_each_entry(sid, pos, head, node)
 		if (sid->id == id)
 			return sid->evsel;
 	return NULL;
 }
 union perf_event *perf_evlist__mmap_read(struct perf_evlist *evlist, int idx)
 {
 	/* XXX Move this to perf.c, making it generally available */
 	unsigned int page_size = sysconf(_SC_PAGE_SIZE);
 	struct perf_mmap *md = &evlist->mmap[idx];
 	unsigned int head = perf_mmap__read_head(md);
 	unsigned int old = md->prev;
 	unsigned char *data = md->base + page_size;
 	union perf_event *event = NULL;
 	if (evlist->overwrite) {
 		/*
 		 * If we're further behind than half the buffer, there's a chance
 		 * the writer will bite our tail and mess up the samples under us.
 		 *
 		 * If we somehow ended up ahead of the head, we got messed up.
 		 *
 		 * In either case, truncate and restart at head.
 		 */
 		int diff = head - old;
 		if (diff > md->mask / 2 || diff < 0) {
 			fprintf(stderr, "WARNING: failed to keep up with mmap data.\n");
 			/*
 			 * head points to a known good entry, start there.
 			 */
 			old = head;
 		}
 	}
 	if (old != head) {
 		size_t size;
 		event = (union perf_event *)&data[old & md->mask];
 		size = event->header.size;
 		/*
 		 * Event straddles the mmap boundary -- header should always
 		 * be inside due to u64 alignment of output.
 		 */
 		if ((old & md->mask) + size != ((old + size) & md->mask)) {
 			unsigned int offset = old;
 			unsigned int len = min(sizeof(*event), size), cpy;
 			void *dst = &evlist->event_copy;
 			do {
 				cpy = min(md->mask + 1 - (offset & md->mask), len);
 				memcpy(dst, &data[offset & md->mask], cpy);
 				offset += cpy;
 				dst += cpy;
 				len -= cpy;
 			} while (len);
 			event = &evlist->event_copy;
 		}
 		old += size;
 	}
 	md->prev = old;
 	if (!evlist->overwrite)
 		perf_mmap__write_tail(md, old);
 	return event;
 }
 void perf_evlist__munmap(struct perf_evlist *evlist)
 {
 	int i;
 	for (i = 0; i < evlist->nr_mmaps; i++) {
 		if (evlist->mmap[i].base != NULL) {
 			munmap(evlist->mmap[i].base, evlist->mmap_len);
 			evlist->mmap[i].base = NULL;
 		}
 	}
 	free(evlist->mmap);
 	evlist->mmap = NULL;
 }
 int perf_evlist__alloc_mmap(struct perf_evlist *evlist)
 {
 	evlist->nr_mmaps = evlist->cpus->nr;
 	if (evlist->cpus->map[0] == -1)
 		evlist->nr_mmaps = evlist->threads->nr;
 	evlist->mmap = zalloc(evlist->nr_mmaps * sizeof(struct perf_mmap));
 	return evlist->mmap != NULL ? 0 : -ENOMEM;
 }
 static int __perf_evlist__mmap(struct perf_evlist *evlist,
 			       int idx, int prot, int mask, int fd)
 {
 	evlist->mmap[idx].prev = 0;
 	evlist->mmap[idx].mask = mask;
 	evlist->mmap[idx].base = mmap(NULL, evlist->mmap_len, prot,
 				      MAP_SHARED, fd, 0);
 	if (evlist->mmap[idx].base == MAP_FAILED)
 		return -1;
 	perf_evlist__add_pollfd(evlist, fd);
 	return 0;
 }
 static int perf_evlist__mmap_per_cpu(struct perf_evlist *evlist, int prot, int mask)
 {
 	struct perf_evsel *evsel;
 	int cpu, thread;
 	for (cpu = 0; cpu < evlist->cpus->nr; cpu++) {
 		int output = -1;
 		for (thread = 0; thread < evlist->threads->nr; thread++) {
 			list_for_each_entry(evsel, &evlist->entries, node) {
 				int fd = FD(evsel, cpu, thread);
 				if (output == -1) {
 					output = fd;
 					if (__perf_evlist__mmap(evlist, cpu,
 								prot, mask, output) < 0)
 						goto out_unmap;
 				} else {
 					if (ioctl(fd, PERF_EVENT_IOC_SET_OUTPUT, output) != 0)
 						goto out_unmap;
 				}
 				if ((evsel->attr.read_format & PERF_FORMAT_ID) &&
 				    perf_evlist__id_add_fd(evlist, evsel, cpu, thread, fd) < 0)
 					goto out_unmap;
 			}
 		}
 	}
 	return 0;
 out_unmap:
 	for (cpu = 0; cpu < evlist->cpus->nr; cpu++) {
 		if (evlist->mmap[cpu].base != NULL) {
 			munmap(evlist->mmap[cpu].base, evlist->mmap_len);
 			evlist->mmap[cpu].base = NULL;
 		}
 	}
 	return -1;
 }
 static int perf_evlist__mmap_per_thread(struct perf_evlist *evlist, int prot, int mask)
 {
 	struct perf_evsel *evsel;
 	int thread;
 	for (thread = 0; thread < evlist->threads->nr; thread++) {
 		int output = -1;
 		list_for_each_entry(evsel, &evlist->entries, node) {
 			int fd = FD(evsel, 0, thread);
 			if (output == -1) {
 				output = fd;
 				if (__perf_evlist__mmap(evlist, thread,
 							prot, mask, output) < 0)
 					goto out_unmap;
 			} else {
 				if (ioctl(fd, PERF_EVENT_IOC_SET_OUTPUT, output) != 0)
 					goto out_unmap;
 			}
 			if ((evsel->attr.read_format & PERF_FORMAT_ID) &&
 			    perf_evlist__id_add_fd(evlist, evsel, 0, thread, fd) < 0)
 				goto out_unmap;
 		}
 	}
 	return 0;
 out_unmap:
 	for (thread = 0; thread < evlist->threads->nr; thread++) {
 		if (evlist->mmap[thread].base != NULL) {
 			munmap(evlist->mmap[thread].base, evlist->mmap_len);
 			evlist->mmap[thread].base = NULL;
 		}
 	}
 	return -1;
 }
 /** perf_evlist__mmap - Create per cpu maps to receive events
  *
  * @evlist - list of events
  * @pages - map length in pages
  * @overwrite - overwrite older events?
  *
  * If overwrite is false the user needs to signal event consuption using:
  *
  *	struct perf_mmap *m = &evlist->mmap[cpu];
  *	unsigned int head = perf_mmap__read_head(m);
  *
  *	perf_mmap__write_tail(m, head)
  *
  * Using perf_evlist__read_on_cpu does this automatically.
  */
 int perf_evlist__mmap(struct perf_evlist *evlist, int pages, bool overwrite)
 {
 	unsigned int page_size = sysconf(_SC_PAGE_SIZE);
 	int mask = pages * page_size - 1;
 	struct perf_evsel *evsel;
 	const struct cpu_map *cpus = evlist->cpus;
 	const struct thread_map *threads = evlist->threads;
 	int prot = PROT_READ | (overwrite ? 0 : PROT_WRITE);
 	if (evlist->mmap == NULL && perf_evlist__alloc_mmap(evlist) < 0)
 		return -ENOMEM;
 	if (evlist->pollfd == NULL && perf_evlist__alloc_pollfd(evlist) < 0)
 		return -ENOMEM;
 	evlist->overwrite = overwrite;
 	evlist->mmap_len = (pages + 1) * page_size;
 	list_for_each_entry(evsel, &evlist->entries, node) {
 		if ((evsel->attr.read_format & PERF_FORMAT_ID) &&
 		    evsel->sample_id == NULL &&
 		    perf_evsel__alloc_id(evsel, cpus->nr, threads->nr) < 0)
 			return -ENOMEM;
 	}
 	if (evlist->cpus->map[0] == -1)
 		return perf_evlist__mmap_per_thread(evlist, prot, mask);
 	return perf_evlist__mmap_per_cpu(evlist, prot, mask);
 }
 int perf_evlist__create_maps(struct perf_evlist *evlist, pid_t target_pid,
 			     pid_t target_tid, const char *cpu_list)
 {
 	evlist->threads = thread_map__new(target_pid, target_tid);
 	if (evlist->threads == NULL)
 		return -1;
 	if (cpu_list == NULL && target_tid != -1)
 		evlist->cpus = cpu_map__dummy_new();
 	else
 		evlist->cpus = cpu_map__new(cpu_list);
 	if (evlist->cpus == NULL)
 		goto out_delete_threads;
 	return 0;
 out_delete_threads:
 	thread_map__delete(evlist->threads);
 	return -1;
 }
 void perf_evlist__delete_maps(struct perf_evlist *evlist)
 {
 	cpu_map__delete(evlist->cpus);
 	thread_map__delete(evlist->threads);
 	evlist->cpus	= NULL;
 	evlist->threads = NULL;
 }
 int perf_evlist__set_filters(struct perf_evlist *evlist)
 {
 	const struct thread_map *threads = evlist->threads;
 	const struct cpu_map *cpus = evlist->cpus;
 	struct perf_evsel *evsel;
 	char *filter;
 	int thread;
 	int cpu;
 	int err;
 	int fd;
 	list_for_each_entry(evsel, &evlist->entries, node) {
 		filter = evsel->filter;
 		if (!filter)
 			continue;
 		for (cpu = 0; cpu < cpus->nr; cpu++) {
 			for (thread = 0; thread < threads->nr; thread++) {
 				fd = FD(evsel, cpu, thread);
 				err = ioctl(fd, PERF_EVENT_IOC_SET_FILTER, filter);
 				if (err)
 					return err;
 			}
 		}
 	}
 	return 0;
 }
 bool perf_evlist__valid_sample_type(const struct perf_evlist *evlist)
 {
 	struct perf_evsel *pos, *first;
 	pos = first = list_entry(evlist->entries.next, struct perf_evsel, node);
 	list_for_each_entry_continue(pos, &evlist->entries, node) {
 		if (first->attr.sample_type != pos->attr.sample_type)
 			return false;
 	}
 	return true;
 }
 u64 perf_evlist__sample_type(const struct perf_evlist *evlist)
 {
 	struct perf_evsel *first;
 	first = list_entry(evlist->entries.next, struct perf_evsel, node);
 	return first->attr.sample_type;
 }
 bool perf_evlist__valid_sample_id_all(const struct perf_evlist *evlist)
 {
 	struct perf_evsel *pos, *first;
 	pos = first = list_entry(evlist->entries.next, struct perf_evsel, node);
 	list_for_each_entry_continue(pos, &evlist->entries, node) {
 		if (first->attr.sample_id_all != pos->attr.sample_id_all)
 			return false;
 	}
 	return true;
 }
 bool perf_evlist__sample_id_all(const struct perf_evlist *evlist)
 {
 	struct perf_evsel *first;
 	first = list_entry(evlist->entries.next, struct perf_evsel, node);
 	return first->attr.sample_id_all;
 }

tools/perf/util/evlist.h

Diff comments View file @ 1d229d5

 #ifndef __PERF_EVLIST_H
 #define __PERF_EVLIST_H 1
 #include <linux/list.h>
 #include "../perf.h"
 #include "event.h"
 struct pollfd;
 struct thread_map;
 struct cpu_map;
 #define PERF_EVLIST__HLIST_BITS 8
 #define PERF_EVLIST__HLIST_SIZE (1 << PERF_EVLIST__HLIST_BITS)
 struct perf_evlist {
 	struct list_head entries;
 	struct hlist_head heads[PERF_EVLIST__HLIST_SIZE];
 	int		 nr_entries;
 	int		 nr_fds;
 	int		 nr_mmaps;
 	int		 mmap_len;
 	bool		 overwrite;
 	union perf_event event_copy;
 	struct perf_mmap *mmap;
 	struct pollfd	 *pollfd;
 	struct thread_map *threads;
 	struct cpu_map	  *cpus;
 };
 struct perf_evsel;
 struct perf_evlist *perf_evlist__new(struct cpu_map *cpus,
 				     struct thread_map *threads);
 void perf_evlist__init(struct perf_evlist *evlist, struct cpu_map *cpus,
 		       struct thread_map *threads);
 void perf_evlist__exit(struct perf_evlist *evlist);
 void perf_evlist__delete(struct perf_evlist *evlist);
 void perf_evlist__add(struct perf_evlist *evlist, struct perf_evsel *entry);
 int perf_evlist__add_default(struct perf_evlist *evlist);
 void perf_evlist__id_add(struct perf_evlist *evlist, struct perf_evsel *evsel,
 			 int cpu, int thread, u64 id);
 int perf_evlist__alloc_pollfd(struct perf_evlist *evlist);
 void perf_evlist__add_pollfd(struct perf_evlist *evlist, int fd);
 struct perf_evsel *perf_evlist__id2evsel(struct perf_evlist *evlist, u64 id);
 union perf_event *perf_evlist__mmap_read(struct perf_evlist *self, int idx);
 int perf_evlist__alloc_mmap(struct perf_evlist *evlist);
 int perf_evlist__mmap(struct perf_evlist *evlist, int pages, bool overwrite);
 void perf_evlist__munmap(struct perf_evlist *evlist);
+void perf_evlist__disable(struct perf_evlist *evlist);
 static inline void perf_evlist__set_maps(struct perf_evlist *evlist,
 					 struct cpu_map *cpus,
 					 struct thread_map *threads)
 {
 	evlist->cpus	= cpus;
 	evlist->threads	= threads;
 }
 int perf_evlist__create_maps(struct perf_evlist *evlist, pid_t target_pid,
 			     pid_t target_tid, const char *cpu_list);
 void perf_evlist__delete_maps(struct perf_evlist *evlist);
 int perf_evlist__set_filters(struct perf_evlist *evlist);
 u64 perf_evlist__sample_type(const struct perf_evlist *evlist);
 bool perf_evlist__sample_id_all(const const struct perf_evlist *evlist);
 bool perf_evlist__valid_sample_type(const struct perf_evlist *evlist);
 bool perf_evlist__valid_sample_id_all(const struct perf_evlist *evlist);
 #endif /* __PERF_EVLIST_H */

tools/perf/util/header.c

Diff comments View file @ 1d229d5

1	#define _FILE_OFFSET_BITS 64	1	#define _FILE_OFFSET_BITS 64
2		2
3	#include <sys/types.h>	3	#include <sys/types.h>
4	#include <byteswap.h>	4	#include <byteswap.h>
5	#include <unistd.h>	5	#include <unistd.h>
6	#include <stdio.h>	6	#include <stdio.h>
7	#include <stdlib.h>	7	#include <stdlib.h>
8	#include <linux/list.h>	8	#include <linux/list.h>
9	#include <linux/kernel.h>	9	#include <linux/kernel.h>
10		10
11	#include "evlist.h"	11	#include "evlist.h"
12	#include "evsel.h"	12	#include "evsel.h"
13	#include "util.h"	13	#include "util.h"
14	#include "header.h"	14	#include "header.h"
15	#include "../perf.h"	15	#include "../perf.h"
16	#include "trace-event.h"	16	#include "trace-event.h"
17	#include "session.h"	17	#include "session.h"
18	#include "symbol.h"	18	#include "symbol.h"
19	#include "debug.h"	19	#include "debug.h"
20		20
21	static bool no_buildid_cache = false;	21	static bool no_buildid_cache = false;
22		22
23	static int event_count;	23	static int event_count;
24	static struct perf_trace_event_type *events;	24	static struct perf_trace_event_type *events;
25		25
26	int perf_header__push_event(u64 id, const char *name)	26	int perf_header__push_event(u64 id, const char *name)
27	{	27	{
28	if (strlen(name) > MAX_EVENT_NAME)	28	if (strlen(name) > MAX_EVENT_NAME)
29	pr_warning("Event %s will be truncated\n", name);	29	pr_warning("Event %s will be truncated\n", name);
30		30
31	if (!events) {	31	if (!events) {
32	events = malloc(sizeof(struct perf_trace_event_type));	32	events = malloc(sizeof(struct perf_trace_event_type));
33	if (events == NULL)	33	if (events == NULL)
34	return -ENOMEM;	34	return -ENOMEM;
35	} else {	35	} else {
36	struct perf_trace_event_type *nevents;	36	struct perf_trace_event_type *nevents;
37		37
38	nevents = realloc(events, (event_count + 1) * sizeof(*events));	38	nevents = realloc(events, (event_count + 1) * sizeof(*events));
39	if (nevents == NULL)	39	if (nevents == NULL)
40	return -ENOMEM;	40	return -ENOMEM;
41	events = nevents;	41	events = nevents;
42	}	42	}
43	memset(&events[event_count], 0, sizeof(struct perf_trace_event_type));	43	memset(&events[event_count], 0, sizeof(struct perf_trace_event_type));
44	events[event_count].event_id = id;	44	events[event_count].event_id = id;
45	strncpy(events[event_count].name, name, MAX_EVENT_NAME - 1);	45	strncpy(events[event_count].name, name, MAX_EVENT_NAME - 1);
46	event_count++;	46	event_count++;
47	return 0;	47	return 0;
48	}	48	}
49		49
50	char *perf_header__find_event(u64 id)	50	char *perf_header__find_event(u64 id)
51	{	51	{
52	int i;	52	int i;
53	for (i = 0 ; i < event_count; i++) {	53	for (i = 0 ; i < event_count; i++) {
54	if (events[i].event_id == id)	54	if (events[i].event_id == id)
55	return events[i].name;	55	return events[i].name;
56	}	56	}
57	return NULL;	57	return NULL;
58	}	58	}
59		59
60	static const char *__perf_magic = "PERFFILE";	60	static const char *__perf_magic = "PERFFILE";
61		61
62	#define PERF_MAGIC ((u64 )__perf_magic)	62	#define PERF_MAGIC ((u64 )__perf_magic)
63		63
64	struct perf_file_attr {	64	struct perf_file_attr {
65	struct perf_event_attr attr;	65	struct perf_event_attr attr;
66	struct perf_file_section ids;	66	struct perf_file_section ids;
67	};	67	};
68		68
69	void perf_header__set_feat(struct perf_header *header, int feat)	69	void perf_header__set_feat(struct perf_header *header, int feat)
70	{	70	{
71	set_bit(feat, header->adds_features);	71	set_bit(feat, header->adds_features);
72	}	72	}
73		73
74	void perf_header__clear_feat(struct perf_header *header, int feat)	74	void perf_header__clear_feat(struct perf_header *header, int feat)
75	{	75	{
76	clear_bit(feat, header->adds_features);	76	clear_bit(feat, header->adds_features);
77	}	77	}
78		78
79	bool perf_header__has_feat(const struct perf_header *header, int feat)	79	bool perf_header__has_feat(const struct perf_header *header, int feat)
80	{	80	{
81	return test_bit(feat, header->adds_features);	81	return test_bit(feat, header->adds_features);
82	}	82	}
83		83
84	static int do_write(int fd, const void *buf, size_t size)	84	static int do_write(int fd, const void *buf, size_t size)
85	{	85	{
86	while (size) {	86	while (size) {
87	int ret = write(fd, buf, size);	87	int ret = write(fd, buf, size);
88		88
89	if (ret < 0)	89	if (ret < 0)
90	return -errno;	90	return -errno;
91		91
92	size -= ret;	92	size -= ret;
93	buf += ret;	93	buf += ret;
94	}	94	}
95		95
96	return 0;	96	return 0;
97	}	97	}
98		98
99	#define NAME_ALIGN 64	99	#define NAME_ALIGN 64
100		100
101	static int write_padded(int fd, const void *bf, size_t count,	101	static int write_padded(int fd, const void *bf, size_t count,
102	size_t count_aligned)	102	size_t count_aligned)
103	{	103	{
104	static const char zero_buf[NAME_ALIGN];	104	static const char zero_buf[NAME_ALIGN];
105	int err = do_write(fd, bf, count);	105	int err = do_write(fd, bf, count);
106		106
107	if (!err)	107	if (!err)
108	err = do_write(fd, zero_buf, count_aligned - count);	108	err = do_write(fd, zero_buf, count_aligned - count);
109		109
110	return err;	110	return err;
111	}	111	}
112		112
113	#define dsos__for_each_with_build_id(pos, head) \	113	#define dsos__for_each_with_build_id(pos, head) \
114	list_for_each_entry(pos, head, node) \	114	list_for_each_entry(pos, head, node) \
115	if (!pos->has_build_id) \	115	if (!pos->has_build_id) \
116	continue; \	116	continue; \
117	else	117	else
118		118
119	static int __dsos__write_buildid_table(struct list_head *head, pid_t pid,	119	static int __dsos__write_buildid_table(struct list_head *head, pid_t pid,
120	u16 misc, int fd)	120	u16 misc, int fd)
121	{	121	{
122	struct dso *pos;	122	struct dso *pos;
123		123
124	dsos__for_each_with_build_id(pos, head) {	124	dsos__for_each_with_build_id(pos, head) {
125	int err;	125	int err;
126	struct build_id_event b;	126	struct build_id_event b;
127	size_t len;	127	size_t len;
128		128
129	if (!pos->hit)	129	if (!pos->hit)
130	continue;	130	continue;
131	len = pos->long_name_len + 1;	131	len = pos->long_name_len + 1;
132	len = ALIGN(len, NAME_ALIGN);	132	len = ALIGN(len, NAME_ALIGN);
133	memset(&b, 0, sizeof(b));	133	memset(&b, 0, sizeof(b));
134	memcpy(&b.build_id, pos->build_id, sizeof(pos->build_id));	134	memcpy(&b.build_id, pos->build_id, sizeof(pos->build_id));
135	b.pid = pid;	135	b.pid = pid;
136	b.header.misc = misc;	136	b.header.misc = misc;
137	b.header.size = sizeof(b) + len;	137	b.header.size = sizeof(b) + len;
138	err = do_write(fd, &b, sizeof(b));	138	err = do_write(fd, &b, sizeof(b));
139	if (err < 0)	139	if (err < 0)
140	return err;	140	return err;
141	err = write_padded(fd, pos->long_name,	141	err = write_padded(fd, pos->long_name,
142	pos->long_name_len + 1, len);	142	pos->long_name_len + 1, len);
143	if (err < 0)	143	if (err < 0)
144	return err;	144	return err;
145	}	145	}
146		146
147	return 0;	147	return 0;
148	}	148	}
149		149
150	static int machine__write_buildid_table(struct machine *machine, int fd)	150	static int machine__write_buildid_table(struct machine *machine, int fd)
151	{	151	{
152	int err;	152	int err;
153	u16 kmisc = PERF_RECORD_MISC_KERNEL,	153	u16 kmisc = PERF_RECORD_MISC_KERNEL,
154	umisc = PERF_RECORD_MISC_USER;	154	umisc = PERF_RECORD_MISC_USER;
155		155
156	if (!machine__is_host(machine)) {	156	if (!machine__is_host(machine)) {
157	kmisc = PERF_RECORD_MISC_GUEST_KERNEL;	157	kmisc = PERF_RECORD_MISC_GUEST_KERNEL;
158	umisc = PERF_RECORD_MISC_GUEST_USER;	158	umisc = PERF_RECORD_MISC_GUEST_USER;
159	}	159	}
160		160
161	err = __dsos__write_buildid_table(&machine->kernel_dsos, machine->pid,	161	err = __dsos__write_buildid_table(&machine->kernel_dsos, machine->pid,
162	kmisc, fd);	162	kmisc, fd);
163	if (err == 0)	163	if (err == 0)
164	err = __dsos__write_buildid_table(&machine->user_dsos,	164	err = __dsos__write_buildid_table(&machine->user_dsos,
165	machine->pid, umisc, fd);	165	machine->pid, umisc, fd);
166	return err;	166	return err;
167	}	167	}
168		168
169	static int dsos__write_buildid_table(struct perf_header *header, int fd)	169	static int dsos__write_buildid_table(struct perf_header *header, int fd)
170	{	170	{
171	struct perf_session *session = container_of(header,	171	struct perf_session *session = container_of(header,
172	struct perf_session, header);	172	struct perf_session, header);
173	struct rb_node *nd;	173	struct rb_node *nd;
174	int err = machine__write_buildid_table(&session->host_machine, fd);	174	int err = machine__write_buildid_table(&session->host_machine, fd);
175		175
176	if (err)	176	if (err)
177	return err;	177	return err;
178		178
179	for (nd = rb_first(&session->machines); nd; nd = rb_next(nd)) {	179	for (nd = rb_first(&session->machines); nd; nd = rb_next(nd)) {
180	struct machine *pos = rb_entry(nd, struct machine, rb_node);	180	struct machine *pos = rb_entry(nd, struct machine, rb_node);
181	err = machine__write_buildid_table(pos, fd);	181	err = machine__write_buildid_table(pos, fd);
182	if (err)	182	if (err)
183	break;	183	break;
184	}	184	}
185	return err;	185	return err;
186	}	186	}
187		187
188	int build_id_cache__add_s(const char sbuild_id, const char debugdir,	188	int build_id_cache__add_s(const char sbuild_id, const char debugdir,
189	const char *name, bool is_kallsyms)	189	const char *name, bool is_kallsyms)
190	{	190	{
191	const size_t size = PATH_MAX;	191	const size_t size = PATH_MAX;
192	char realname, filename = malloc(size),	192	char realname, filename = zalloc(size),
193	linkname = malloc(size), targetname;	193	linkname = zalloc(size), targetname;
194	int len, err = -1;	194	int len, err = -1;
195		195
196	if (is_kallsyms) {	196	if (is_kallsyms) {
197	if (symbol_conf.kptr_restrict) {	197	if (symbol_conf.kptr_restrict) {
198	pr_debug("Not caching a kptr_restrict'ed /proc/kallsyms\n");	198	pr_debug("Not caching a kptr_restrict'ed /proc/kallsyms\n");
199	return 0;	199	return 0;
200	}	200	}
201	realname = (char *)name;	201	realname = (char *)name;
202	} else	202	} else
203	realname = realpath(name, NULL);	203	realname = realpath(name, NULL);
204		204
205	if (realname == NULL \|\| filename == NULL \|\| linkname == NULL)	205	if (realname == NULL \|\| filename == NULL \|\| linkname == NULL)
206	goto out_free;	206	goto out_free;
207		207
208	len = snprintf(filename, size, "%s%s%s",	208	len = snprintf(filename, size, "%s%s%s",
209	debugdir, is_kallsyms ? "/" : "", realname);	209	debugdir, is_kallsyms ? "/" : "", realname);
210	if (mkdir_p(filename, 0755))	210	if (mkdir_p(filename, 0755))
211	goto out_free;	211	goto out_free;
212		212
213	snprintf(filename + len, sizeof(filename) - len, "/%s", sbuild_id);	213	snprintf(filename + len, sizeof(filename) - len, "/%s", sbuild_id);
214		214
215	if (access(filename, F_OK)) {	215	if (access(filename, F_OK)) {
216	if (is_kallsyms) {	216	if (is_kallsyms) {
217	if (copyfile("/proc/kallsyms", filename))	217	if (copyfile("/proc/kallsyms", filename))
218	goto out_free;	218	goto out_free;
219	} else if (link(realname, filename) && copyfile(name, filename))	219	} else if (link(realname, filename) && copyfile(name, filename))
220	goto out_free;	220	goto out_free;
221	}	221	}
222		222
223	len = snprintf(linkname, size, "%s/.build-id/%.2s",	223	len = snprintf(linkname, size, "%s/.build-id/%.2s",
224	debugdir, sbuild_id);	224	debugdir, sbuild_id);
225		225
226	if (access(linkname, X_OK) && mkdir_p(linkname, 0755))	226	if (access(linkname, X_OK) && mkdir_p(linkname, 0755))
227	goto out_free;	227	goto out_free;
228		228
229	snprintf(linkname + len, size - len, "/%s", sbuild_id + 2);	229	snprintf(linkname + len, size - len, "/%s", sbuild_id + 2);
230	targetname = filename + strlen(debugdir) - 5;	230	targetname = filename + strlen(debugdir) - 5;
231	memcpy(targetname, "../..", 5);	231	memcpy(targetname, "../..", 5);
232		232
233	if (symlink(targetname, linkname) == 0)	233	if (symlink(targetname, linkname) == 0)
234	err = 0;	234	err = 0;
235	out_free:	235	out_free:
236	if (!is_kallsyms)	236	if (!is_kallsyms)
237	free(realname);	237	free(realname);
238	free(filename);	238	free(filename);
239	free(linkname);	239	free(linkname);
240	return err;	240	return err;
241	}	241	}
242		242
243	static int build_id_cache__add_b(const u8 *build_id, size_t build_id_size,	243	static int build_id_cache__add_b(const u8 *build_id, size_t build_id_size,
244	const char name, const char debugdir,	244	const char name, const char debugdir,
245	bool is_kallsyms)	245	bool is_kallsyms)
246	{	246	{
247	char sbuild_id[BUILD_ID_SIZE * 2 + 1];	247	char sbuild_id[BUILD_ID_SIZE * 2 + 1];
248		248
249	build_id__sprintf(build_id, build_id_size, sbuild_id);	249	build_id__sprintf(build_id, build_id_size, sbuild_id);
250		250
251	return build_id_cache__add_s(sbuild_id, debugdir, name, is_kallsyms);	251	return build_id_cache__add_s(sbuild_id, debugdir, name, is_kallsyms);
252	}	252	}
253		253
254	int build_id_cache__remove_s(const char sbuild_id, const char debugdir)	254	int build_id_cache__remove_s(const char sbuild_id, const char debugdir)
255	{	255	{
256	const size_t size = PATH_MAX;	256	const size_t size = PATH_MAX;
257	char *filename = malloc(size),	257	char *filename = zalloc(size),
258	*linkname = malloc(size);	258	*linkname = zalloc(size);
259	int err = -1;	259	int err = -1;
260		260
261	if (filename == NULL \|\| linkname == NULL)	261	if (filename == NULL \|\| linkname == NULL)
262	goto out_free;	262	goto out_free;
263		263
264	snprintf(linkname, size, "%s/.build-id/%.2s/%s",	264	snprintf(linkname, size, "%s/.build-id/%.2s/%s",
265	debugdir, sbuild_id, sbuild_id + 2);	265	debugdir, sbuild_id, sbuild_id + 2);
266		266
267	if (access(linkname, F_OK))	267	if (access(linkname, F_OK))
268	goto out_free;	268	goto out_free;
269		269
270	if (readlink(linkname, filename, size) < 0)	270	if (readlink(linkname, filename, size) < 0)
271	goto out_free;	271	goto out_free;
272		272
273	if (unlink(linkname))	273	if (unlink(linkname))
274	goto out_free;	274	goto out_free;
275		275
276	/*	276	/*
277	* Since the link is relative, we must make it absolute:	277	* Since the link is relative, we must make it absolute:
278	*/	278	*/
279	snprintf(linkname, size, "%s/.build-id/%.2s/%s",	279	snprintf(linkname, size, "%s/.build-id/%.2s/%s",
280	debugdir, sbuild_id, filename);	280	debugdir, sbuild_id, filename);
281		281
282	if (unlink(linkname))	282	if (unlink(linkname))
283	goto out_free;	283	goto out_free;
284		284
285	err = 0;	285	err = 0;
286	out_free:	286	out_free:
287	free(filename);	287	free(filename);
288	free(linkname);	288	free(linkname);
289	return err;	289	return err;
290	}	290	}
291		291
292	static int dso__cache_build_id(struct dso dso, const char debugdir)	292	static int dso__cache_build_id(struct dso dso, const char debugdir)
293	{	293	{
294	bool is_kallsyms = dso->kernel && dso->long_name[0] != '/';	294	bool is_kallsyms = dso->kernel && dso->long_name[0] != '/';
295		295
296	return build_id_cache__add_b(dso->build_id, sizeof(dso->build_id),	296	return build_id_cache__add_b(dso->build_id, sizeof(dso->build_id),
297	dso->long_name, debugdir, is_kallsyms);	297	dso->long_name, debugdir, is_kallsyms);
298	}	298	}
299		299
300	static int __dsos__cache_build_ids(struct list_head head, const char debugdir)	300	static int __dsos__cache_build_ids(struct list_head head, const char debugdir)
301	{	301	{
302	struct dso *pos;	302	struct dso *pos;
303	int err = 0;	303	int err = 0;
304		304
305	dsos__for_each_with_build_id(pos, head)	305	dsos__for_each_with_build_id(pos, head)
306	if (dso__cache_build_id(pos, debugdir))	306	if (dso__cache_build_id(pos, debugdir))
307	err = -1;	307	err = -1;
308		308
309	return err;	309	return err;
310	}	310	}
311		311
312	static int machine__cache_build_ids(struct machine machine, const char debugdir)	312	static int machine__cache_build_ids(struct machine machine, const char debugdir)
313	{	313	{
314	int ret = __dsos__cache_build_ids(&machine->kernel_dsos, debugdir);	314	int ret = __dsos__cache_build_ids(&machine->kernel_dsos, debugdir);
315	ret \|= __dsos__cache_build_ids(&machine->user_dsos, debugdir);	315	ret \|= __dsos__cache_build_ids(&machine->user_dsos, debugdir);
316	return ret;	316	return ret;
317	}	317	}
318		318
319	static int perf_session__cache_build_ids(struct perf_session *session)	319	static int perf_session__cache_build_ids(struct perf_session *session)
320	{	320	{
321	struct rb_node *nd;	321	struct rb_node *nd;
322	int ret;	322	int ret;
323	char debugdir[PATH_MAX];	323	char debugdir[PATH_MAX];
324		324
325	snprintf(debugdir, sizeof(debugdir), "%s", buildid_dir);	325	snprintf(debugdir, sizeof(debugdir), "%s", buildid_dir);
326		326
327	if (mkdir(debugdir, 0755) != 0 && errno != EEXIST)	327	if (mkdir(debugdir, 0755) != 0 && errno != EEXIST)
328	return -1;	328	return -1;
329		329
330	ret = machine__cache_build_ids(&session->host_machine, debugdir);	330	ret = machine__cache_build_ids(&session->host_machine, debugdir);
331		331
332	for (nd = rb_first(&session->machines); nd; nd = rb_next(nd)) {	332	for (nd = rb_first(&session->machines); nd; nd = rb_next(nd)) {
333	struct machine *pos = rb_entry(nd, struct machine, rb_node);	333	struct machine *pos = rb_entry(nd, struct machine, rb_node);
334	ret \|= machine__cache_build_ids(pos, debugdir);	334	ret \|= machine__cache_build_ids(pos, debugdir);
335	}	335	}
336	return ret ? -1 : 0;	336	return ret ? -1 : 0;
337	}	337	}
338		338
339	static bool machine__read_build_ids(struct machine *machine, bool with_hits)	339	static bool machine__read_build_ids(struct machine *machine, bool with_hits)
340	{	340	{
341	bool ret = __dsos__read_build_ids(&machine->kernel_dsos, with_hits);	341	bool ret = __dsos__read_build_ids(&machine->kernel_dsos, with_hits);
342	ret \|= __dsos__read_build_ids(&machine->user_dsos, with_hits);	342	ret \|= __dsos__read_build_ids(&machine->user_dsos, with_hits);
343	return ret;	343	return ret;
344	}	344	}
345		345
346	static bool perf_session__read_build_ids(struct perf_session *session, bool with_hits)	346	static bool perf_session__read_build_ids(struct perf_session *session, bool with_hits)
347	{	347	{
348	struct rb_node *nd;	348	struct rb_node *nd;
349	bool ret = machine__read_build_ids(&session->host_machine, with_hits);	349	bool ret = machine__read_build_ids(&session->host_machine, with_hits);
350		350
351	for (nd = rb_first(&session->machines); nd; nd = rb_next(nd)) {	351	for (nd = rb_first(&session->machines); nd; nd = rb_next(nd)) {
352	struct machine *pos = rb_entry(nd, struct machine, rb_node);	352	struct machine *pos = rb_entry(nd, struct machine, rb_node);
353	ret \|= machine__read_build_ids(pos, with_hits);	353	ret \|= machine__read_build_ids(pos, with_hits);
354	}	354	}
355		355
356	return ret;	356	return ret;
357	}	357	}
358		358
359	static int perf_header__adds_write(struct perf_header *header,	359	static int perf_header__adds_write(struct perf_header *header,
360	struct perf_evlist *evlist, int fd)	360	struct perf_evlist *evlist, int fd)
361	{	361	{
362	int nr_sections;	362	int nr_sections;
363	struct perf_session *session;	363	struct perf_session *session;
364	struct perf_file_section *feat_sec;	364	struct perf_file_section *feat_sec;
365	int sec_size;	365	int sec_size;
366	u64 sec_start;	366	u64 sec_start;
367	int idx = 0, err;	367	int idx = 0, err;
368		368
369	session = container_of(header, struct perf_session, header);	369	session = container_of(header, struct perf_session, header);
370		370
371	if (perf_header__has_feat(header, HEADER_BUILD_ID &&	371	if (perf_header__has_feat(header, HEADER_BUILD_ID &&
372	!perf_session__read_build_ids(session, true)))	372	!perf_session__read_build_ids(session, true)))
373	perf_header__clear_feat(header, HEADER_BUILD_ID);	373	perf_header__clear_feat(header, HEADER_BUILD_ID);
374		374
375	nr_sections = bitmap_weight(header->adds_features, HEADER_FEAT_BITS);	375	nr_sections = bitmap_weight(header->adds_features, HEADER_FEAT_BITS);
376	if (!nr_sections)	376	if (!nr_sections)
377	return 0;	377	return 0;
378		378
379	feat_sec = calloc(sizeof(*feat_sec), nr_sections);	379	feat_sec = calloc(sizeof(*feat_sec), nr_sections);
380	if (feat_sec == NULL)	380	if (feat_sec == NULL)
381	return -ENOMEM;	381	return -ENOMEM;
382		382
383	sec_size = sizeof(feat_sec) nr_sections;	383	sec_size = sizeof(feat_sec) nr_sections;
384		384
385	sec_start = header->data_offset + header->data_size;	385	sec_start = header->data_offset + header->data_size;
386	lseek(fd, sec_start + sec_size, SEEK_SET);	386	lseek(fd, sec_start + sec_size, SEEK_SET);
387		387
388	if (perf_header__has_feat(header, HEADER_TRACE_INFO)) {	388	if (perf_header__has_feat(header, HEADER_TRACE_INFO)) {
389	struct perf_file_section *trace_sec;	389	struct perf_file_section *trace_sec;
390		390
391	trace_sec = &feat_sec[idx++];	391	trace_sec = &feat_sec[idx++];
392		392
393	/* Write trace info */	393	/* Write trace info */
394	trace_sec->offset = lseek(fd, 0, SEEK_CUR);	394	trace_sec->offset = lseek(fd, 0, SEEK_CUR);
395	read_tracing_data(fd, &evlist->entries);	395	read_tracing_data(fd, &evlist->entries);
396	trace_sec->size = lseek(fd, 0, SEEK_CUR) - trace_sec->offset;	396	trace_sec->size = lseek(fd, 0, SEEK_CUR) - trace_sec->offset;
397	}	397	}
398		398
399	if (perf_header__has_feat(header, HEADER_BUILD_ID)) {	399	if (perf_header__has_feat(header, HEADER_BUILD_ID)) {
400	struct perf_file_section *buildid_sec;	400	struct perf_file_section *buildid_sec;
401		401
402	buildid_sec = &feat_sec[idx++];	402	buildid_sec = &feat_sec[idx++];
403		403
404	/* Write build-ids */	404	/* Write build-ids */
405	buildid_sec->offset = lseek(fd, 0, SEEK_CUR);	405	buildid_sec->offset = lseek(fd, 0, SEEK_CUR);
406	err = dsos__write_buildid_table(header, fd);	406	err = dsos__write_buildid_table(header, fd);
407	if (err < 0) {	407	if (err < 0) {
408	pr_debug("failed to write buildid table\n");	408	pr_debug("failed to write buildid table\n");
409	goto out_free;	409	goto out_free;
410	}	410	}
411	buildid_sec->size = lseek(fd, 0, SEEK_CUR) -	411	buildid_sec->size = lseek(fd, 0, SEEK_CUR) -
412	buildid_sec->offset;	412	buildid_sec->offset;
413	if (!no_buildid_cache)	413	if (!no_buildid_cache)
414	perf_session__cache_build_ids(session);	414	perf_session__cache_build_ids(session);
415	}	415	}
416		416
417	lseek(fd, sec_start, SEEK_SET);	417	lseek(fd, sec_start, SEEK_SET);
418	err = do_write(fd, feat_sec, sec_size);	418	err = do_write(fd, feat_sec, sec_size);
419	if (err < 0)	419	if (err < 0)
420	pr_debug("failed to write feature section\n");	420	pr_debug("failed to write feature section\n");
421	out_free:	421	out_free:
422	free(feat_sec);	422	free(feat_sec);
423	return err;	423	return err;
424	}	424	}
425		425
426	int perf_header__write_pipe(int fd)	426	int perf_header__write_pipe(int fd)
427	{	427	{
428	struct perf_pipe_file_header f_header;	428	struct perf_pipe_file_header f_header;
429	int err;	429	int err;
430		430
431	f_header = (struct perf_pipe_file_header){	431	f_header = (struct perf_pipe_file_header){
432	.magic = PERF_MAGIC,	432	.magic = PERF_MAGIC,
433	.size = sizeof(f_header),	433	.size = sizeof(f_header),
434	};	434	};
435		435
436	err = do_write(fd, &f_header, sizeof(f_header));	436	err = do_write(fd, &f_header, sizeof(f_header));
437	if (err < 0) {	437	if (err < 0) {
438	pr_debug("failed to write perf pipe header\n");	438	pr_debug("failed to write perf pipe header\n");
439	return err;	439	return err;
440	}	440	}
441		441
442	return 0;	442	return 0;
443	}	443	}
444		444
445	int perf_session__write_header(struct perf_session *session,	445	int perf_session__write_header(struct perf_session *session,
446	struct perf_evlist *evlist,	446	struct perf_evlist *evlist,
447	int fd, bool at_exit)	447	int fd, bool at_exit)
448	{	448	{
449	struct perf_file_header f_header;	449	struct perf_file_header f_header;
450	struct perf_file_attr f_attr;	450	struct perf_file_attr f_attr;
451	struct perf_header *header = &session->header;	451	struct perf_header *header = &session->header;
452	struct perf_evsel attr, pair = NULL;	452	struct perf_evsel attr, pair = NULL;
453	int err;	453	int err;
454		454
455	lseek(fd, sizeof(f_header), SEEK_SET);	455	lseek(fd, sizeof(f_header), SEEK_SET);
456		456
457	if (session->evlist != evlist)	457	if (session->evlist != evlist)
458	pair = list_entry(session->evlist->entries.next, struct perf_evsel, node);	458	pair = list_entry(session->evlist->entries.next, struct perf_evsel, node);
459		459
460	list_for_each_entry(attr, &evlist->entries, node) {	460	list_for_each_entry(attr, &evlist->entries, node) {
461	attr->id_offset = lseek(fd, 0, SEEK_CUR);	461	attr->id_offset = lseek(fd, 0, SEEK_CUR);
462	err = do_write(fd, attr->id, attr->ids * sizeof(u64));	462	err = do_write(fd, attr->id, attr->ids * sizeof(u64));
463	if (err < 0) {	463	if (err < 0) {
464	out_err_write:	464	out_err_write:
465	pr_debug("failed to write perf header\n");	465	pr_debug("failed to write perf header\n");
466	return err;	466	return err;
467	}	467	}
468	if (session->evlist != evlist) {	468	if (session->evlist != evlist) {
469	err = do_write(fd, pair->id, pair->ids * sizeof(u64));	469	err = do_write(fd, pair->id, pair->ids * sizeof(u64));
470	if (err < 0)	470	if (err < 0)
471	goto out_err_write;	471	goto out_err_write;
472	attr->ids += pair->ids;	472	attr->ids += pair->ids;
473	pair = list_entry(pair->node.next, struct perf_evsel, node);	473	pair = list_entry(pair->node.next, struct perf_evsel, node);
474	}	474	}
475	}	475	}
476		476
477	header->attr_offset = lseek(fd, 0, SEEK_CUR);	477	header->attr_offset = lseek(fd, 0, SEEK_CUR);
478		478
479	list_for_each_entry(attr, &evlist->entries, node) {	479	list_for_each_entry(attr, &evlist->entries, node) {
480	f_attr = (struct perf_file_attr){	480	f_attr = (struct perf_file_attr){
481	.attr = attr->attr,	481	.attr = attr->attr,
482	.ids = {	482	.ids = {
483	.offset = attr->id_offset,	483	.offset = attr->id_offset,
484	.size = attr->ids * sizeof(u64),	484	.size = attr->ids * sizeof(u64),
485	}	485	}
486	};	486	};
487	err = do_write(fd, &f_attr, sizeof(f_attr));	487	err = do_write(fd, &f_attr, sizeof(f_attr));
488	if (err < 0) {	488	if (err < 0) {
489	pr_debug("failed to write perf header attribute\n");	489	pr_debug("failed to write perf header attribute\n");
490	return err;	490	return err;
491	}	491	}
492	}	492	}
493		493
494	header->event_offset = lseek(fd, 0, SEEK_CUR);	494	header->event_offset = lseek(fd, 0, SEEK_CUR);
495	header->event_size = event_count * sizeof(struct perf_trace_event_type);	495	header->event_size = event_count * sizeof(struct perf_trace_event_type);
496	if (events) {	496	if (events) {
497	err = do_write(fd, events, header->event_size);	497	err = do_write(fd, events, header->event_size);
498	if (err < 0) {	498	if (err < 0) {
499	pr_debug("failed to write perf header events\n");	499	pr_debug("failed to write perf header events\n");
500	return err;	500	return err;
501	}	501	}
502	}	502	}
503		503
504	header->data_offset = lseek(fd, 0, SEEK_CUR);	504	header->data_offset = lseek(fd, 0, SEEK_CUR);
505		505
506	if (at_exit) {	506	if (at_exit) {
507	err = perf_header__adds_write(header, evlist, fd);	507	err = perf_header__adds_write(header, evlist, fd);
508	if (err < 0)	508	if (err < 0)
509	return err;	509	return err;
510	}	510	}
511		511
512	f_header = (struct perf_file_header){	512	f_header = (struct perf_file_header){
513	.magic = PERF_MAGIC,	513	.magic = PERF_MAGIC,
514	.size = sizeof(f_header),	514	.size = sizeof(f_header),
515	.attr_size = sizeof(f_attr),	515	.attr_size = sizeof(f_attr),
516	.attrs = {	516	.attrs = {
517	.offset = header->attr_offset,	517	.offset = header->attr_offset,
518	.size = evlist->nr_entries * sizeof(f_attr),	518	.size = evlist->nr_entries * sizeof(f_attr),
519	},	519	},
520	.data = {	520	.data = {
521	.offset = header->data_offset,	521	.offset = header->data_offset,
522	.size = header->data_size,	522	.size = header->data_size,
523	},	523	},
524	.event_types = {	524	.event_types = {
525	.offset = header->event_offset,	525	.offset = header->event_offset,
526	.size = header->event_size,	526	.size = header->event_size,
527	},	527	},
528	};	528	};
529		529
530	memcpy(&f_header.adds_features, &header->adds_features, sizeof(header->adds_features));	530	memcpy(&f_header.adds_features, &header->adds_features, sizeof(header->adds_features));
531		531
532	lseek(fd, 0, SEEK_SET);	532	lseek(fd, 0, SEEK_SET);
533	err = do_write(fd, &f_header, sizeof(f_header));	533	err = do_write(fd, &f_header, sizeof(f_header));
534	if (err < 0) {	534	if (err < 0) {
535	pr_debug("failed to write perf header\n");	535	pr_debug("failed to write perf header\n");
536	return err;	536	return err;
537	}	537	}
538	lseek(fd, header->data_offset + header->data_size, SEEK_SET);	538	lseek(fd, header->data_offset + header->data_size, SEEK_SET);
539		539
540	header->frozen = 1;	540	header->frozen = 1;
541	return 0;	541	return 0;
542	}	542	}
543		543
544	static int perf_header__getbuffer64(struct perf_header *header,	544	static int perf_header__getbuffer64(struct perf_header *header,
545	int fd, void *buf, size_t size)	545	int fd, void *buf, size_t size)
546	{	546	{
547	if (readn(fd, buf, size) <= 0)	547	if (readn(fd, buf, size) <= 0)
548	return -1;	548	return -1;
549		549
550	if (header->needs_swap)	550	if (header->needs_swap)
551	mem_bswap_64(buf, size);	551	mem_bswap_64(buf, size);
552		552
553	return 0;	553	return 0;
554	}	554	}
555		555
556	int perf_header__process_sections(struct perf_header *header, int fd,	556	int perf_header__process_sections(struct perf_header *header, int fd,
557	int (process)(struct perf_file_section section,	557	int (process)(struct perf_file_section section,
558	struct perf_header *ph,	558	struct perf_header *ph,
559	int feat, int fd))	559	int feat, int fd))
560	{	560	{
561	struct perf_file_section *feat_sec;	561	struct perf_file_section *feat_sec;
562	int nr_sections;	562	int nr_sections;
563	int sec_size;	563	int sec_size;
564	int idx = 0;	564	int idx = 0;
565	int err = -1, feat = 1;	565	int err = -1, feat = 1;
566		566
567	nr_sections = bitmap_weight(header->adds_features, HEADER_FEAT_BITS);	567	nr_sections = bitmap_weight(header->adds_features, HEADER_FEAT_BITS);
568	if (!nr_sections)	568	if (!nr_sections)
569	return 0;	569	return 0;
570		570
571	feat_sec = calloc(sizeof(*feat_sec), nr_sections);	571	feat_sec = calloc(sizeof(*feat_sec), nr_sections);
572	if (!feat_sec)	572	if (!feat_sec)
573	return -1;	573	return -1;
574		574
575	sec_size = sizeof(feat_sec) nr_sections;	575	sec_size = sizeof(feat_sec) nr_sections;
576		576
577	lseek(fd, header->data_offset + header->data_size, SEEK_SET);	577	lseek(fd, header->data_offset + header->data_size, SEEK_SET);
578		578
579	if (perf_header__getbuffer64(header, fd, feat_sec, sec_size))	579	if (perf_header__getbuffer64(header, fd, feat_sec, sec_size))
580	goto out_free;	580	goto out_free;
581		581
582	err = 0;	582	err = 0;
583	while (idx < nr_sections && feat < HEADER_LAST_FEATURE) {	583	while (idx < nr_sections && feat < HEADER_LAST_FEATURE) {
584	if (perf_header__has_feat(header, feat)) {	584	if (perf_header__has_feat(header, feat)) {
585	struct perf_file_section *sec = &feat_sec[idx++];	585	struct perf_file_section *sec = &feat_sec[idx++];
586		586
587	err = process(sec, header, feat, fd);	587	err = process(sec, header, feat, fd);
588	if (err < 0)	588	if (err < 0)
589	break;	589	break;
590	}	590	}
591	++feat;	591	++feat;
592	}	592	}
593	out_free:	593	out_free:
594	free(feat_sec);	594	free(feat_sec);
595	return err;	595	return err;
596	}	596	}
597		597
598	int perf_file_header__read(struct perf_file_header *header,	598	int perf_file_header__read(struct perf_file_header *header,
599	struct perf_header *ph, int fd)	599	struct perf_header *ph, int fd)
600	{	600	{
601	lseek(fd, 0, SEEK_SET);	601	lseek(fd, 0, SEEK_SET);
602		602
603	if (readn(fd, header, sizeof(*header)) <= 0 \|\|	603	if (readn(fd, header, sizeof(*header)) <= 0 \|\|
604	memcmp(&header->magic, __perf_magic, sizeof(header->magic)))	604	memcmp(&header->magic, __perf_magic, sizeof(header->magic)))
605	return -1;	605	return -1;
606		606
607	if (header->attr_size != sizeof(struct perf_file_attr)) {	607	if (header->attr_size != sizeof(struct perf_file_attr)) {
608	u64 attr_size = bswap_64(header->attr_size);	608	u64 attr_size = bswap_64(header->attr_size);
609		609
610	if (attr_size != sizeof(struct perf_file_attr))	610	if (attr_size != sizeof(struct perf_file_attr))
611	return -1;	611	return -1;
612		612
613	mem_bswap_64(header, offsetof(struct perf_file_header,	613	mem_bswap_64(header, offsetof(struct perf_file_header,
614	adds_features));	614	adds_features));
615	ph->needs_swap = true;	615	ph->needs_swap = true;
616	}	616	}
617		617
618	if (header->size != sizeof(*header)) {	618	if (header->size != sizeof(*header)) {
619	/* Support the previous format */	619	/* Support the previous format */
620	if (header->size == offsetof(typeof(*header), adds_features))	620	if (header->size == offsetof(typeof(*header), adds_features))
621	bitmap_zero(header->adds_features, HEADER_FEAT_BITS);	621	bitmap_zero(header->adds_features, HEADER_FEAT_BITS);
622	else	622	else
623	return -1;	623	return -1;
624	}	624	}
625		625
626	memcpy(&ph->adds_features, &header->adds_features,	626	memcpy(&ph->adds_features, &header->adds_features,
627	sizeof(ph->adds_features));	627	sizeof(ph->adds_features));
628	/*	628	/*
629	* FIXME: hack that assumes that if we need swap the perf.data file	629	* FIXME: hack that assumes that if we need swap the perf.data file
630	* may be coming from an arch with a different word-size, ergo different	630	* may be coming from an arch with a different word-size, ergo different
631	* DEFINE_BITMAP format, investigate more later, but for now its mostly	631	* DEFINE_BITMAP format, investigate more later, but for now its mostly
632	* safe to assume that we have a build-id section. Trace files probably	632	* safe to assume that we have a build-id section. Trace files probably
633	* have several other issues in this realm anyway...	633	* have several other issues in this realm anyway...
634	*/	634	*/
635	if (ph->needs_swap) {	635	if (ph->needs_swap) {
636	memset(&ph->adds_features, 0, sizeof(ph->adds_features));	636	memset(&ph->adds_features, 0, sizeof(ph->adds_features));
637	perf_header__set_feat(ph, HEADER_BUILD_ID);	637	perf_header__set_feat(ph, HEADER_BUILD_ID);
638	}	638	}
639		639
640	ph->event_offset = header->event_types.offset;	640	ph->event_offset = header->event_types.offset;
641	ph->event_size = header->event_types.size;	641	ph->event_size = header->event_types.size;
642	ph->data_offset = header->data.offset;	642	ph->data_offset = header->data.offset;
643	ph->data_size = header->data.size;	643	ph->data_size = header->data.size;
644	return 0;	644	return 0;
645	}	645	}
646		646
647	static int __event_process_build_id(struct build_id_event *bev,	647	static int __event_process_build_id(struct build_id_event *bev,
648	char *filename,	648	char *filename,
649	struct perf_session *session)	649	struct perf_session *session)
650	{	650	{
651	int err = -1;	651	int err = -1;
652	struct list_head *head;	652	struct list_head *head;
653	struct machine *machine;	653	struct machine *machine;
654	u16 misc;	654	u16 misc;
655	struct dso *dso;	655	struct dso *dso;
656	enum dso_kernel_type dso_type;	656	enum dso_kernel_type dso_type;
657		657
658	machine = perf_session__findnew_machine(session, bev->pid);	658	machine = perf_session__findnew_machine(session, bev->pid);
659	if (!machine)	659	if (!machine)
660	goto out;	660	goto out;
661		661
662	misc = bev->header.misc & PERF_RECORD_MISC_CPUMODE_MASK;	662	misc = bev->header.misc & PERF_RECORD_MISC_CPUMODE_MASK;
663		663
664	switch (misc) {	664	switch (misc) {
665	case PERF_RECORD_MISC_KERNEL:	665	case PERF_RECORD_MISC_KERNEL:
666	dso_type = DSO_TYPE_KERNEL;	666	dso_type = DSO_TYPE_KERNEL;
667	head = &machine->kernel_dsos;	667	head = &machine->kernel_dsos;
668	break;	668	break;
669	case PERF_RECORD_MISC_GUEST_KERNEL:	669	case PERF_RECORD_MISC_GUEST_KERNEL:
670	dso_type = DSO_TYPE_GUEST_KERNEL;	670	dso_type = DSO_TYPE_GUEST_KERNEL;
671	head = &machine->kernel_dsos;	671	head = &machine->kernel_dsos;
672	break;	672	break;
673	case PERF_RECORD_MISC_USER:	673	case PERF_RECORD_MISC_USER:
674	case PERF_RECORD_MISC_GUEST_USER:	674	case PERF_RECORD_MISC_GUEST_USER:
675	dso_type = DSO_TYPE_USER;	675	dso_type = DSO_TYPE_USER;
676	head = &machine->user_dsos;	676	head = &machine->user_dsos;
677	break;	677	break;
678	default:	678	default:
679	goto out;	679	goto out;
680	}	680	}
681		681
682	dso = __dsos__findnew(head, filename);	682	dso = __dsos__findnew(head, filename);
683	if (dso != NULL) {	683	if (dso != NULL) {
684	char sbuild_id[BUILD_ID_SIZE * 2 + 1];	684	char sbuild_id[BUILD_ID_SIZE * 2 + 1];
685		685
686	dso__set_build_id(dso, &bev->build_id);	686	dso__set_build_id(dso, &bev->build_id);
687		687
688	if (filename[0] == '[')	688	if (filename[0] == '[')
689	dso->kernel = dso_type;	689	dso->kernel = dso_type;
690		690
691	build_id__sprintf(dso->build_id, sizeof(dso->build_id),	691	build_id__sprintf(dso->build_id, sizeof(dso->build_id),
692	sbuild_id);	692	sbuild_id);
693	pr_debug("build id event received for %s: %s\n",	693	pr_debug("build id event received for %s: %s\n",
694	dso->long_name, sbuild_id);	694	dso->long_name, sbuild_id);
695	}	695	}
696		696
697	err = 0;	697	err = 0;
698	out:	698	out:
699	return err;	699	return err;
700	}	700	}
701		701
702	static int perf_header__read_build_ids_abi_quirk(struct perf_header *header,	702	static int perf_header__read_build_ids_abi_quirk(struct perf_header *header,
703	int input, u64 offset, u64 size)	703	int input, u64 offset, u64 size)
704	{	704	{
705	struct perf_session *session = container_of(header, struct perf_session, header);	705	struct perf_session *session = container_of(header, struct perf_session, header);
706	struct {	706	struct {
707	struct perf_event_header header;	707	struct perf_event_header header;
708	u8 build_id[ALIGN(BUILD_ID_SIZE, sizeof(u64))];	708	u8 build_id[ALIGN(BUILD_ID_SIZE, sizeof(u64))];
709	char filename[0];	709	char filename[0];
710	} old_bev;	710	} old_bev;
711	struct build_id_event bev;	711	struct build_id_event bev;
712	char filename[PATH_MAX];	712	char filename[PATH_MAX];
713	u64 limit = offset + size;	713	u64 limit = offset + size;
714		714
715	while (offset < limit) {	715	while (offset < limit) {
716	ssize_t len;	716	ssize_t len;
717		717
718	if (read(input, &old_bev, sizeof(old_bev)) != sizeof(old_bev))	718	if (read(input, &old_bev, sizeof(old_bev)) != sizeof(old_bev))
719	return -1;	719	return -1;
720		720
721	if (header->needs_swap)	721	if (header->needs_swap)
722	perf_event_header__bswap(&old_bev.header);	722	perf_event_header__bswap(&old_bev.header);
723		723
724	len = old_bev.header.size - sizeof(old_bev);	724	len = old_bev.header.size - sizeof(old_bev);
725	if (read(input, filename, len) != len)	725	if (read(input, filename, len) != len)
726	return -1;	726	return -1;
727		727
728	bev.header = old_bev.header;	728	bev.header = old_bev.header;
729	bev.pid = 0;	729	bev.pid = 0;
730	memcpy(bev.build_id, old_bev.build_id, sizeof(bev.build_id));	730	memcpy(bev.build_id, old_bev.build_id, sizeof(bev.build_id));
731	__event_process_build_id(&bev, filename, session);	731	__event_process_build_id(&bev, filename, session);
732		732
733	offset += bev.header.size;	733	offset += bev.header.size;
734	}	734	}
735		735
736	return 0;	736	return 0;
737	}	737	}
738		738
739	static int perf_header__read_build_ids(struct perf_header *header,	739	static int perf_header__read_build_ids(struct perf_header *header,
740	int input, u64 offset, u64 size)	740	int input, u64 offset, u64 size)
741	{	741	{
742	struct perf_session *session = container_of(header, struct perf_session, header);	742	struct perf_session *session = container_of(header, struct perf_session, header);
743	struct build_id_event bev;	743	struct build_id_event bev;
744	char filename[PATH_MAX];	744	char filename[PATH_MAX];
745	u64 limit = offset + size, orig_offset = offset;	745	u64 limit = offset + size, orig_offset = offset;
746	int err = -1;	746	int err = -1;
747		747
748	while (offset < limit) {	748	while (offset < limit) {
749	ssize_t len;	749	ssize_t len;
750		750
751	if (read(input, &bev, sizeof(bev)) != sizeof(bev))	751	if (read(input, &bev, sizeof(bev)) != sizeof(bev))
752	goto out;	752	goto out;
753		753
754	if (header->needs_swap)	754	if (header->needs_swap)
755	perf_event_header__bswap(&bev.header);	755	perf_event_header__bswap(&bev.header);
756		756
757	len = bev.header.size - sizeof(bev);	757	len = bev.header.size - sizeof(bev);
758	if (read(input, filename, len) != len)	758	if (read(input, filename, len) != len)
759	goto out;	759	goto out;
760	/*	760	/*
761	* The a1645ce1 changeset:	761	* The a1645ce1 changeset:
762	*	762	*
763	* "perf: 'perf kvm' tool for monitoring guest performance from host"	763	* "perf: 'perf kvm' tool for monitoring guest performance from host"
764	*	764	*
765	* Added a field to struct build_id_event that broke the file	765	* Added a field to struct build_id_event that broke the file
766	* format.	766	* format.
767	*	767	*
768	* Since the kernel build-id is the first entry, process the	768	* Since the kernel build-id is the first entry, process the
769	* table using the old format if the well known	769	* table using the old format if the well known
770	* '[kernel.kallsyms]' string for the kernel build-id has the	770	* '[kernel.kallsyms]' string for the kernel build-id has the
771	* first 4 characters chopped off (where the pid_t sits).	771	* first 4 characters chopped off (where the pid_t sits).
772	*/	772	*/
773	if (memcmp(filename, "nel.kallsyms]", 13) == 0) {	773	if (memcmp(filename, "nel.kallsyms]", 13) == 0) {
774	if (lseek(input, orig_offset, SEEK_SET) == (off_t)-1)	774	if (lseek(input, orig_offset, SEEK_SET) == (off_t)-1)
775	return -1;	775	return -1;
776	return perf_header__read_build_ids_abi_quirk(header, input, offset, size);	776	return perf_header__read_build_ids_abi_quirk(header, input, offset, size);
777	}	777	}
778		778
779	__event_process_build_id(&bev, filename, session);	779	__event_process_build_id(&bev, filename, session);
780		780
781	offset += bev.header.size;	781	offset += bev.header.size;
782	}	782	}
783	err = 0;	783	err = 0;
784	out:	784	out:
785	return err;	785	return err;
786	}	786	}
787		787
788	static int perf_file_section__process(struct perf_file_section *section,	788	static int perf_file_section__process(struct perf_file_section *section,
789	struct perf_header *ph,	789	struct perf_header *ph,
790	int feat, int fd)	790	int feat, int fd)
791	{	791	{
792	if (lseek(fd, section->offset, SEEK_SET) == (off_t)-1) {	792	if (lseek(fd, section->offset, SEEK_SET) == (off_t)-1) {
793	pr_debug("Failed to lseek to %" PRIu64 " offset for feature "	793	pr_debug("Failed to lseek to %" PRIu64 " offset for feature "
794	"%d, continuing...\n", section->offset, feat);	794	"%d, continuing...\n", section->offset, feat);
795	return 0;	795	return 0;
796	}	796	}
797		797
798	switch (feat) {	798	switch (feat) {
799	case HEADER_TRACE_INFO:	799	case HEADER_TRACE_INFO:
800	trace_report(fd, false);	800	trace_report(fd, false);
801	break;	801	break;
802		802
803	case HEADER_BUILD_ID:	803	case HEADER_BUILD_ID:
804	if (perf_header__read_build_ids(ph, fd, section->offset, section->size))	804	if (perf_header__read_build_ids(ph, fd, section->offset, section->size))
805	pr_debug("Failed to read buildids, continuing...\n");	805	pr_debug("Failed to read buildids, continuing...\n");
806	break;	806	break;
807	default:	807	default:
808	pr_debug("unknown feature %d, continuing...\n", feat);	808	pr_debug("unknown feature %d, continuing...\n", feat);
809	}	809	}
810		810
811	return 0;	811	return 0;
812	}	812	}
813		813
814	static int perf_file_header__read_pipe(struct perf_pipe_file_header *header,	814	static int perf_file_header__read_pipe(struct perf_pipe_file_header *header,
815	struct perf_header *ph, int fd,	815	struct perf_header *ph, int fd,
816	bool repipe)	816	bool repipe)
817	{	817	{
818	if (readn(fd, header, sizeof(*header)) <= 0 \|\|	818	if (readn(fd, header, sizeof(*header)) <= 0 \|\|
819	memcmp(&header->magic, __perf_magic, sizeof(header->magic)))	819	memcmp(&header->magic, __perf_magic, sizeof(header->magic)))
820	return -1;	820	return -1;
821		821
822	if (repipe && do_write(STDOUT_FILENO, header, sizeof(*header)) < 0)	822	if (repipe && do_write(STDOUT_FILENO, header, sizeof(*header)) < 0)
823	return -1;	823	return -1;
824		824
825	if (header->size != sizeof(*header)) {	825	if (header->size != sizeof(*header)) {
826	u64 size = bswap_64(header->size);	826	u64 size = bswap_64(header->size);
827		827
828	if (size != sizeof(*header))	828	if (size != sizeof(*header))
829	return -1;	829	return -1;
830		830
831	ph->needs_swap = true;	831	ph->needs_swap = true;
832	}	832	}
833		833
834	return 0;	834	return 0;
835	}	835	}
836		836
837	static int perf_header__read_pipe(struct perf_session *session, int fd)	837	static int perf_header__read_pipe(struct perf_session *session, int fd)
838	{	838	{
839	struct perf_header *header = &session->header;	839	struct perf_header *header = &session->header;
840	struct perf_pipe_file_header f_header;	840	struct perf_pipe_file_header f_header;
841		841
842	if (perf_file_header__read_pipe(&f_header, header, fd,	842	if (perf_file_header__read_pipe(&f_header, header, fd,
843	session->repipe) < 0) {	843	session->repipe) < 0) {
844	pr_debug("incompatible file format\n");	844	pr_debug("incompatible file format\n");
845	return -EINVAL;	845	return -EINVAL;
846	}	846	}
847		847
848	session->fd = fd;	848	session->fd = fd;
849		849
850	return 0;	850	return 0;
851	}	851	}
852		852
853	int perf_session__read_header(struct perf_session *session, int fd)	853	int perf_session__read_header(struct perf_session *session, int fd)
854	{	854	{
855	struct perf_header *header = &session->header;	855	struct perf_header *header = &session->header;
856	struct perf_file_header f_header;	856	struct perf_file_header f_header;
857	struct perf_file_attr f_attr;	857	struct perf_file_attr f_attr;
858	u64 f_id;	858	u64 f_id;
859	int nr_attrs, nr_ids, i, j;	859	int nr_attrs, nr_ids, i, j;
860		860
861	session->evlist = perf_evlist__new(NULL, NULL);	861	session->evlist = perf_evlist__new(NULL, NULL);
862	if (session->evlist == NULL)	862	if (session->evlist == NULL)
863	return -ENOMEM;	863	return -ENOMEM;
864		864
865	if (session->fd_pipe)	865	if (session->fd_pipe)
866	return perf_header__read_pipe(session, fd);	866	return perf_header__read_pipe(session, fd);
867		867
868	if (perf_file_header__read(&f_header, header, fd) < 0) {	868	if (perf_file_header__read(&f_header, header, fd) < 0) {
869	pr_debug("incompatible file format\n");	869	pr_debug("incompatible file format\n");
870	return -EINVAL;	870	return -EINVAL;
871	}	871	}
872		872
873	nr_attrs = f_header.attrs.size / sizeof(f_attr);	873	nr_attrs = f_header.attrs.size / sizeof(f_attr);
874	lseek(fd, f_header.attrs.offset, SEEK_SET);	874	lseek(fd, f_header.attrs.offset, SEEK_SET);
875		875
876	for (i = 0; i < nr_attrs; i++) {	876	for (i = 0; i < nr_attrs; i++) {
877	struct perf_evsel *evsel;	877	struct perf_evsel *evsel;
878	off_t tmp;	878	off_t tmp;
879		879
880	if (readn(fd, &f_attr, sizeof(f_attr)) <= 0)	880	if (readn(fd, &f_attr, sizeof(f_attr)) <= 0)
881	goto out_errno;	881	goto out_errno;
882		882
883	if (header->needs_swap)	883	if (header->needs_swap)
884	perf_event__attr_swap(&f_attr.attr);	884	perf_event__attr_swap(&f_attr.attr);
885		885
886	tmp = lseek(fd, 0, SEEK_CUR);	886	tmp = lseek(fd, 0, SEEK_CUR);
887	evsel = perf_evsel__new(&f_attr.attr, i);	887	evsel = perf_evsel__new(&f_attr.attr, i);
888		888
889	if (evsel == NULL)	889	if (evsel == NULL)
890	goto out_delete_evlist;	890	goto out_delete_evlist;
891	/*	891	/*
892	* Do it before so that if perf_evsel__alloc_id fails, this	892	* Do it before so that if perf_evsel__alloc_id fails, this
893	* entry gets purged too at perf_evlist__delete().	893	* entry gets purged too at perf_evlist__delete().
894	*/	894	*/
895	perf_evlist__add(session->evlist, evsel);	895	perf_evlist__add(session->evlist, evsel);
896		896
897	nr_ids = f_attr.ids.size / sizeof(u64);	897	nr_ids = f_attr.ids.size / sizeof(u64);
898	/*	898	/*
899	* We don't have the cpu and thread maps on the header, so	899	* We don't have the cpu and thread maps on the header, so
900	* for allocating the perf_sample_id table we fake 1 cpu and	900	* for allocating the perf_sample_id table we fake 1 cpu and
901	* hattr->ids threads.	901	* hattr->ids threads.
902	*/	902	*/
903	if (perf_evsel__alloc_id(evsel, 1, nr_ids))	903	if (perf_evsel__alloc_id(evsel, 1, nr_ids))
904	goto out_delete_evlist;	904	goto out_delete_evlist;
905		905
906	lseek(fd, f_attr.ids.offset, SEEK_SET);	906	lseek(fd, f_attr.ids.offset, SEEK_SET);
907		907
908	for (j = 0; j < nr_ids; j++) {	908	for (j = 0; j < nr_ids; j++) {
909	if (perf_header__getbuffer64(header, fd, &f_id, sizeof(f_id)))	909	if (perf_header__getbuffer64(header, fd, &f_id, sizeof(f_id)))
910	goto out_errno;	910	goto out_errno;
911		911
912	perf_evlist__id_add(session->evlist, evsel, 0, j, f_id);	912	perf_evlist__id_add(session->evlist, evsel, 0, j, f_id);
913	}	913	}
914		914
915	lseek(fd, tmp, SEEK_SET);	915	lseek(fd, tmp, SEEK_SET);
916	}	916	}
917		917
918	if (f_header.event_types.size) {	918	if (f_header.event_types.size) {
919	lseek(fd, f_header.event_types.offset, SEEK_SET);	919	lseek(fd, f_header.event_types.offset, SEEK_SET);
920	events = malloc(f_header.event_types.size);	920	events = malloc(f_header.event_types.size);
921	if (events == NULL)	921	if (events == NULL)
922	return -ENOMEM;	922	return -ENOMEM;
923	if (perf_header__getbuffer64(header, fd, events,	923	if (perf_header__getbuffer64(header, fd, events,
924	f_header.event_types.size))	924	f_header.event_types.size))
925	goto out_errno;	925	goto out_errno;
926	event_count = f_header.event_types.size / sizeof(struct perf_trace_event_type);	926	event_count = f_header.event_types.size / sizeof(struct perf_trace_event_type);
927	}	927	}
928		928
929	perf_header__process_sections(header, fd, perf_file_section__process);	929	perf_header__process_sections(header, fd, perf_file_section__process);
930		930
931	lseek(fd, header->data_offset, SEEK_SET);	931	lseek(fd, header->data_offset, SEEK_SET);
932		932
933	header->frozen = 1;	933	header->frozen = 1;
934	return 0;	934	return 0;
935	out_errno:	935	out_errno:
936	return -errno;	936	return -errno;
937		937
938	out_delete_evlist:	938	out_delete_evlist:
939	perf_evlist__delete(session->evlist);	939	perf_evlist__delete(session->evlist);
940	session->evlist = NULL;	940	session->evlist = NULL;
941	return -ENOMEM;	941	return -ENOMEM;
942	}	942	}
943		943
944	int perf_event__synthesize_attr(struct perf_event_attr attr, u16 ids, u64 id,	944	int perf_event__synthesize_attr(struct perf_event_attr attr, u16 ids, u64 id,
945	perf_event__handler_t process,	945	perf_event__handler_t process,
946	struct perf_session *session)	946	struct perf_session *session)
947	{	947	{
948	union perf_event *ev;	948	union perf_event *ev;
949	size_t size;	949	size_t size;
950	int err;	950	int err;
951		951
952	size = sizeof(struct perf_event_attr);	952	size = sizeof(struct perf_event_attr);
953	size = ALIGN(size, sizeof(u64));	953	size = ALIGN(size, sizeof(u64));
954	size += sizeof(struct perf_event_header);	954	size += sizeof(struct perf_event_header);
955	size += ids * sizeof(u64);	955	size += ids * sizeof(u64);
956		956
957	ev = malloc(size);	957	ev = malloc(size);
958		958
959	if (ev == NULL)	959	if (ev == NULL)
960	return -ENOMEM;	960	return -ENOMEM;
961		961
962	ev->attr.attr = *attr;	962	ev->attr.attr = *attr;
963	memcpy(ev->attr.id, id, ids * sizeof(u64));	963	memcpy(ev->attr.id, id, ids * sizeof(u64));
964		964
965	ev->attr.header.type = PERF_RECORD_HEADER_ATTR;	965	ev->attr.header.type = PERF_RECORD_HEADER_ATTR;
966	ev->attr.header.size = size;	966	ev->attr.header.size = size;
967		967
968	err = process(ev, NULL, session);	968	err = process(ev, NULL, session);
969		969
970	free(ev);	970	free(ev);
971		971
972	return err;	972	return err;
973	}	973	}
974		974
975	int perf_session__synthesize_attrs(struct perf_session *session,	975	int perf_session__synthesize_attrs(struct perf_session *session,
976	perf_event__handler_t process)	976	perf_event__handler_t process)
977	{	977	{
978	struct perf_evsel *attr;	978	struct perf_evsel *attr;
979	int err = 0;	979	int err = 0;
980		980
981	list_for_each_entry(attr, &session->evlist->entries, node) {	981	list_for_each_entry(attr, &session->evlist->entries, node) {
982	err = perf_event__synthesize_attr(&attr->attr, attr->ids,	982	err = perf_event__synthesize_attr(&attr->attr, attr->ids,
983	attr->id, process, session);	983	attr->id, process, session);
984	if (err) {	984	if (err) {
985	pr_debug("failed to create perf header attribute\n");	985	pr_debug("failed to create perf header attribute\n");
986	return err;	986	return err;
987	}	987	}
988	}	988	}
989		989
990	return err;	990	return err;
991	}	991	}
992		992
993	int perf_event__process_attr(union perf_event *event,	993	int perf_event__process_attr(union perf_event *event,
994	struct perf_session *session)	994	struct perf_session *session)
995	{	995	{
996	unsigned int i, ids, n_ids;	996	unsigned int i, ids, n_ids;
997	struct perf_evsel *evsel;	997	struct perf_evsel *evsel;
998		998
999	if (session->evlist == NULL) {	999	if (session->evlist == NULL) {
1000	session->evlist = perf_evlist__new(NULL, NULL);	1000	session->evlist = perf_evlist__new(NULL, NULL);
1001	if (session->evlist == NULL)	1001	if (session->evlist == NULL)
1002	return -ENOMEM;	1002	return -ENOMEM;
1003	}	1003	}
1004		1004
1005	evsel = perf_evsel__new(&event->attr.attr,	1005	evsel = perf_evsel__new(&event->attr.attr,
1006	session->evlist->nr_entries);	1006	session->evlist->nr_entries);
1007	if (evsel == NULL)	1007	if (evsel == NULL)
1008	return -ENOMEM;	1008	return -ENOMEM;
1009		1009
1010	perf_evlist__add(session->evlist, evsel);	1010	perf_evlist__add(session->evlist, evsel);
1011		1011
1012	ids = event->header.size;	1012	ids = event->header.size;
1013	ids -= (void )&event->attr.id - (void )event;	1013	ids -= (void )&event->attr.id - (void )event;
1014	n_ids = ids / sizeof(u64);	1014	n_ids = ids / sizeof(u64);
1015	/*	1015	/*
1016	* We don't have the cpu and thread maps on the header, so	1016	* We don't have the cpu and thread maps on the header, so
1017	* for allocating the perf_sample_id table we fake 1 cpu and	1017	* for allocating the perf_sample_id table we fake 1 cpu and
1018	* hattr->ids threads.	1018	* hattr->ids threads.
1019	*/	1019	*/
1020	if (perf_evsel__alloc_id(evsel, 1, n_ids))	1020	if (perf_evsel__alloc_id(evsel, 1, n_ids))
1021	return -ENOMEM;	1021	return -ENOMEM;
1022		1022
1023	for (i = 0; i < n_ids; i++) {	1023	for (i = 0; i < n_ids; i++) {
1024	perf_evlist__id_add(session->evlist, evsel, 0, i,	1024	perf_evlist__id_add(session->evlist, evsel, 0, i,
1025	event->attr.id[i]);	1025	event->attr.id[i]);
1026	}	1026	}
1027		1027
1028	perf_session__update_sample_type(session);	1028	perf_session__update_sample_type(session);
1029		1029
1030	return 0;	1030	return 0;
1031	}	1031	}
1032		1032
1033	int perf_event__synthesize_event_type(u64 event_id, char *name,	1033	int perf_event__synthesize_event_type(u64 event_id, char *name,
1034	perf_event__handler_t process,	1034	perf_event__handler_t process,
1035	struct perf_session *session)	1035	struct perf_session *session)
1036	{	1036	{
1037	union perf_event ev;	1037	union perf_event ev;
1038	size_t size = 0;	1038	size_t size = 0;
1039	int err = 0;	1039	int err = 0;
1040		1040
1041	memset(&ev, 0, sizeof(ev));	1041	memset(&ev, 0, sizeof(ev));
1042		1042
1043	ev.event_type.event_type.event_id = event_id;	1043	ev.event_type.event_type.event_id = event_id;
1044	memset(ev.event_type.event_type.name, 0, MAX_EVENT_NAME);	1044	memset(ev.event_type.event_type.name, 0, MAX_EVENT_NAME);
1045	strncpy(ev.event_type.event_type.name, name, MAX_EVENT_NAME - 1);	1045	strncpy(ev.event_type.event_type.name, name, MAX_EVENT_NAME - 1);
1046		1046
1047	ev.event_type.header.type = PERF_RECORD_HEADER_EVENT_TYPE;	1047	ev.event_type.header.type = PERF_RECORD_HEADER_EVENT_TYPE;
1048	size = strlen(name);	1048	size = strlen(name);
1049	size = ALIGN(size, sizeof(u64));	1049	size = ALIGN(size, sizeof(u64));
1050	ev.event_type.header.size = sizeof(ev.event_type) -	1050	ev.event_type.header.size = sizeof(ev.event_type) -
1051	(sizeof(ev.event_type.event_type.name) - size);	1051	(sizeof(ev.event_type.event_type.name) - size);
1052		1052
1053	err = process(&ev, NULL, session);	1053	err = process(&ev, NULL, session);
1054		1054
1055	return err;	1055	return err;
1056	}	1056	}
1057		1057
1058	int perf_event__synthesize_event_types(perf_event__handler_t process,	1058	int perf_event__synthesize_event_types(perf_event__handler_t process,
1059	struct perf_session *session)	1059	struct perf_session *session)
1060	{	1060	{
1061	struct perf_trace_event_type *type;	1061	struct perf_trace_event_type *type;
1062	int i, err = 0;	1062	int i, err = 0;
1063		1063
1064	for (i = 0; i < event_count; i++) {	1064	for (i = 0; i < event_count; i++) {
1065	type = &events[i];	1065	type = &events[i];
1066		1066
1067	err = perf_event__synthesize_event_type(type->event_id,	1067	err = perf_event__synthesize_event_type(type->event_id,
1068	type->name, process,	1068	type->name, process,
1069	session);	1069	session);
1070	if (err) {	1070	if (err) {
1071	pr_debug("failed to create perf header event type\n");	1071	pr_debug("failed to create perf header event type\n");
1072	return err;	1072	return err;
1073	}	1073	}
1074	}	1074	}
1075		1075
1076	return err;	1076	return err;
1077	}	1077	}
1078		1078
1079	int perf_event__process_event_type(union perf_event *event,	1079	int perf_event__process_event_type(union perf_event *event,
1080	struct perf_session *session __unused)	1080	struct perf_session *session __unused)
1081	{	1081	{
1082	if (perf_header__push_event(event->event_type.event_type.event_id,	1082	if (perf_header__push_event(event->event_type.event_type.event_id,
1083	event->event_type.event_type.name) < 0)	1083	event->event_type.event_type.name) < 0)
1084	return -ENOMEM;	1084	return -ENOMEM;
1085		1085
1086	return 0;	1086	return 0;
1087	}	1087	}
1088		1088
1089	int perf_event__synthesize_tracing_data(int fd, struct perf_evlist *evlist,	1089	int perf_event__synthesize_tracing_data(int fd, struct perf_evlist *evlist,
1090	perf_event__handler_t process,	1090	perf_event__handler_t process,
1091	struct perf_session *session __unused)	1091	struct perf_session *session __unused)
1092	{	1092	{
1093	union perf_event ev;	1093	union perf_event ev;
1094	ssize_t size = 0, aligned_size = 0, padding;	1094	ssize_t size = 0, aligned_size = 0, padding;
1095	int err __used = 0;	1095	int err __used = 0;
1096		1096
1097	memset(&ev, 0, sizeof(ev));	1097	memset(&ev, 0, sizeof(ev));
1098		1098
1099	ev.tracing_data.header.type = PERF_RECORD_HEADER_TRACING_DATA;	1099	ev.tracing_data.header.type = PERF_RECORD_HEADER_TRACING_DATA;
1100	size = read_tracing_data_size(fd, &evlist->entries);	1100	size = read_tracing_data_size(fd, &evlist->entries);
1101	if (size <= 0)	1101	if (size <= 0)
1102	return size;	1102	return size;
1103	aligned_size = ALIGN(size, sizeof(u64));	1103	aligned_size = ALIGN(size, sizeof(u64));
1104	padding = aligned_size - size;	1104	padding = aligned_size - size;
1105	ev.tracing_data.header.size = sizeof(ev.tracing_data);	1105	ev.tracing_data.header.size = sizeof(ev.tracing_data);
1106	ev.tracing_data.size = aligned_size;	1106	ev.tracing_data.size = aligned_size;
1107		1107
1108	process(&ev, NULL, session);	1108	process(&ev, NULL, session);
1109		1109
1110	err = read_tracing_data(fd, &evlist->entries);	1110	err = read_tracing_data(fd, &evlist->entries);
1111	write_padded(fd, NULL, 0, padding);	1111	write_padded(fd, NULL, 0, padding);
1112		1112
1113	return aligned_size;	1113	return aligned_size;
1114	}	1114	}
1115		1115
1116	int perf_event__process_tracing_data(union perf_event *event,	1116	int perf_event__process_tracing_data(union perf_event *event,
1117	struct perf_session *session)	1117	struct perf_session *session)
1118	{	1118	{
1119	ssize_t size_read, padding, size = event->tracing_data.size;	1119	ssize_t size_read, padding, size = event->tracing_data.size;
1120	off_t offset = lseek(session->fd, 0, SEEK_CUR);	1120	off_t offset = lseek(session->fd, 0, SEEK_CUR);
1121	char buf[BUFSIZ];	1121	char buf[BUFSIZ];
1122		1122
1123	/* setup for reading amidst mmap */	1123	/* setup for reading amidst mmap */
1124	lseek(session->fd, offset + sizeof(struct tracing_data_event),	1124	lseek(session->fd, offset + sizeof(struct tracing_data_event),
1125	SEEK_SET);	1125	SEEK_SET);
1126		1126
1127	size_read = trace_report(session->fd, session->repipe);	1127	size_read = trace_report(session->fd, session->repipe);
1128		1128
1129	padding = ALIGN(size_read, sizeof(u64)) - size_read;	1129	padding = ALIGN(size_read, sizeof(u64)) - size_read;
1130		1130
1131	if (read(session->fd, buf, padding) < 0)	1131	if (read(session->fd, buf, padding) < 0)
1132	die("reading input file");	1132	die("reading input file");
1133	if (session->repipe) {	1133	if (session->repipe) {
1134	int retw = write(STDOUT_FILENO, buf, padding);	1134	int retw = write(STDOUT_FILENO, buf, padding);
1135	if (retw <= 0 \|\| retw != padding)	1135	if (retw <= 0 \|\| retw != padding)
1136	die("repiping tracing data padding");	1136	die("repiping tracing data padding");
1137	}	1137	}
1138		1138
1139	if (size_read + padding != size)	1139	if (size_read + padding != size)
1140	die("tracing data size mismatch");	1140	die("tracing data size mismatch");
1141		1141
1142	return size_read + padding;	1142	return size_read + padding;
1143	}	1143	}
1144		1144
1145	int perf_event__synthesize_build_id(struct dso *pos, u16 misc,	1145	int perf_event__synthesize_build_id(struct dso *pos, u16 misc,
1146	perf_event__handler_t process,	1146	perf_event__handler_t process,
1147	struct machine *machine,	1147	struct machine *machine,
1148	struct perf_session *session)	1148	struct perf_session *session)
1149	{	1149	{
1150	union perf_event ev;	1150	union perf_event ev;
1151	size_t len;	1151	size_t len;
1152	int err = 0;	1152	int err = 0;
1153		1153
1154	if (!pos->hit)	1154	if (!pos->hit)
1155	return err;	1155	return err;
1156		1156
1157	memset(&ev, 0, sizeof(ev));	1157	memset(&ev, 0, sizeof(ev));
1158		1158
1159	len = pos->long_name_len + 1;	1159	len = pos->long_name_len + 1;
1160	len = ALIGN(len, NAME_ALIGN);	1160	len = ALIGN(len, NAME_ALIGN);
1161	memcpy(&ev.build_id.build_id, pos->build_id, sizeof(pos->build_id));	1161	memcpy(&ev.build_id.build_id, pos->build_id, sizeof(pos->build_id));
1162	ev.build_id.header.type = PERF_RECORD_HEADER_BUILD_ID;	1162	ev.build_id.header.type = PERF_RECORD_HEADER_BUILD_ID;
1163	ev.build_id.header.misc = misc;	1163	ev.build_id.header.misc = misc;
1164	ev.build_id.pid = machine->pid;	1164	ev.build_id.pid = machine->pid;
1165	ev.build_id.header.size = sizeof(ev.build_id) + len;	1165	ev.build_id.header.size = sizeof(ev.build_id) + len;
1166	memcpy(&ev.build_id.filename, pos->long_name, pos->long_name_len);	1166	memcpy(&ev.build_id.filename, pos->long_name, pos->long_name_len);
1167		1167
1168	err = process(&ev, NULL, session);	1168	err = process(&ev, NULL, session);
1169		1169
1170	return err;	1170	return err;
1171	}	1171	}
1172		1172
1173	int perf_event__process_build_id(union perf_event *event,	1173	int perf_event__process_build_id(union perf_event *event,
1174	struct perf_session *session)	1174	struct perf_session *session)
1175	{	1175	{
1176	__event_process_build_id(&event->build_id,	1176	__event_process_build_id(&event->build_id,
1177	event->build_id.filename,	1177	event->build_id.filename,
1178	session);	1178	session);
1179	return 0;	1179	return 0;
1180	}	1180	}
1181		1181
1182	void disable_buildid_cache(void)	1182	void disable_buildid_cache(void)
1183	{	1183	{
1184	no_buildid_cache = true;	1184	no_buildid_cache = true;
1185	}	1185	}
1186		1186

tools/perf/util/probe-event.c

Diff comments View file @ 1d229d5

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

tools/perf/util/python.c

Diff comments View file @ 1d229d5

 #include <Python.h>
 #include <structmember.h>
 #include <inttypes.h>
 #include <poll.h>
 #include "evlist.h"
 #include "evsel.h"
 #include "event.h"
 #include "cpumap.h"
 #include "thread_map.h"
 /* Define PyVarObject_HEAD_INIT for python 2.5 */
 #ifndef PyVarObject_HEAD_INIT
 # define PyVarObject_HEAD_INIT(type, size) PyObject_HEAD_INIT(type) size,
 #endif
 struct throttle_event {
 	struct perf_event_header header;
 	u64			 time;
 	u64			 id;
 	u64			 stream_id;
 };
 PyMODINIT_FUNC initperf(void);
 #define member_def(type, member, ptype, help) \
 	{ #member, ptype, \
 	  offsetof(struct pyrf_event, event) + offsetof(struct type, member), \
 	  0, help }
 #define sample_member_def(name, member, ptype, help) \
 	{ #name, ptype, \
 	  offsetof(struct pyrf_event, sample) + offsetof(struct perf_sample, member), \
 	  0, help }
 struct pyrf_event {
 	PyObject_HEAD
 	struct perf_sample sample;
 	union perf_event   event;
 };
 #define sample_members \
 	sample_member_def(sample_ip, ip, T_ULONGLONG, "event type"),			 \
 	sample_member_def(sample_pid, pid, T_INT, "event pid"),			 \
 	sample_member_def(sample_tid, tid, T_INT, "event tid"),			 \
 	sample_member_def(sample_time, time, T_ULONGLONG, "event timestamp"),		 \
 	sample_member_def(sample_addr, addr, T_ULONGLONG, "event addr"),		 \
 	sample_member_def(sample_id, id, T_ULONGLONG, "event id"),			 \
 	sample_member_def(sample_stream_id, stream_id, T_ULONGLONG, "event stream id"), \
 	sample_member_def(sample_period, period, T_ULONGLONG, "event period"),		 \
 	sample_member_def(sample_cpu, cpu, T_UINT, "event cpu"),
 static char pyrf_mmap_event__doc[] = PyDoc_STR("perf mmap event object.");
 static PyMemberDef pyrf_mmap_event__members[] = {
 	sample_members
 	member_def(perf_event_header, type, T_UINT, "event type"),
 	member_def(mmap_event, pid, T_UINT, "event pid"),
 	member_def(mmap_event, tid, T_UINT, "event tid"),
 	member_def(mmap_event, start, T_ULONGLONG, "start of the map"),
 	member_def(mmap_event, len, T_ULONGLONG, "map length"),
 	member_def(mmap_event, pgoff, T_ULONGLONG, "page offset"),
 	member_def(mmap_event, filename, T_STRING_INPLACE, "backing store"),
 	{ .name = NULL, },
 };
 static PyObject *pyrf_mmap_event__repr(struct pyrf_event *pevent)
 {
 	PyObject *ret;
 	char *s;
 	if (asprintf(&s, "{ type: mmap, pid: %u, tid: %u, start: %#" PRIx64 ", "
 			 "length: %#" PRIx64 ", offset: %#" PRIx64 ", "
 			 "filename: %s }",
 		     pevent->event.mmap.pid, pevent->event.mmap.tid,
 		     pevent->event.mmap.start, pevent->event.mmap.len,
 		     pevent->event.mmap.pgoff, pevent->event.mmap.filename) < 0) {
 		ret = PyErr_NoMemory();
 	} else {
 		ret = PyString_FromString(s);
 		free(s);
 	}
 	return ret;
 }
 static PyTypeObject pyrf_mmap_event__type = {
 	PyVarObject_HEAD_INIT(NULL, 0)
 	.tp_name	= "perf.mmap_event",
 	.tp_basicsize	= sizeof(struct pyrf_event),
 	.tp_flags	= Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE,
 	.tp_doc		= pyrf_mmap_event__doc,
 	.tp_members	= pyrf_mmap_event__members,
 	.tp_repr	= (reprfunc)pyrf_mmap_event__repr,
 };
 static char pyrf_task_event__doc[] = PyDoc_STR("perf task (fork/exit) event object.");
 static PyMemberDef pyrf_task_event__members[] = {
 	sample_members
 	member_def(perf_event_header, type, T_UINT, "event type"),
 	member_def(fork_event, pid, T_UINT, "event pid"),
 	member_def(fork_event, ppid, T_UINT, "event ppid"),
 	member_def(fork_event, tid, T_UINT, "event tid"),
 	member_def(fork_event, ptid, T_UINT, "event ptid"),
 	member_def(fork_event, time, T_ULONGLONG, "timestamp"),
 	{ .name = NULL, },
 };
 static PyObject *pyrf_task_event__repr(struct pyrf_event *pevent)
 {
 	return PyString_FromFormat("{ type: %s, pid: %u, ppid: %u, tid: %u, "
 				   "ptid: %u, time: %" PRIu64 "}",
 				   pevent->event.header.type == PERF_RECORD_FORK ? "fork" : "exit",
 				   pevent->event.fork.pid,
 				   pevent->event.fork.ppid,
 				   pevent->event.fork.tid,
 				   pevent->event.fork.ptid,
 				   pevent->event.fork.time);
 }
 static PyTypeObject pyrf_task_event__type = {
 	PyVarObject_HEAD_INIT(NULL, 0)
 	.tp_name	= "perf.task_event",
 	.tp_basicsize	= sizeof(struct pyrf_event),
 	.tp_flags	= Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE,
 	.tp_doc		= pyrf_task_event__doc,
 	.tp_members	= pyrf_task_event__members,
 	.tp_repr	= (reprfunc)pyrf_task_event__repr,
 };
 static char pyrf_comm_event__doc[] = PyDoc_STR("perf comm event object.");
 static PyMemberDef pyrf_comm_event__members[] = {
 	sample_members
 	member_def(perf_event_header, type, T_UINT, "event type"),
 	member_def(comm_event, pid, T_UINT, "event pid"),
 	member_def(comm_event, tid, T_UINT, "event tid"),
 	member_def(comm_event, comm, T_STRING_INPLACE, "process name"),
 	{ .name = NULL, },
 };
 static PyObject *pyrf_comm_event__repr(struct pyrf_event *pevent)
 {
 	return PyString_FromFormat("{ type: comm, pid: %u, tid: %u, comm: %s }",
 				   pevent->event.comm.pid,
 				   pevent->event.comm.tid,
 				   pevent->event.comm.comm);
 }
 static PyTypeObject pyrf_comm_event__type = {
 	PyVarObject_HEAD_INIT(NULL, 0)
 	.tp_name	= "perf.comm_event",
 	.tp_basicsize	= sizeof(struct pyrf_event),
 	.tp_flags	= Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE,
 	.tp_doc		= pyrf_comm_event__doc,
 	.tp_members	= pyrf_comm_event__members,
 	.tp_repr	= (reprfunc)pyrf_comm_event__repr,
 };
 static char pyrf_throttle_event__doc[] = PyDoc_STR("perf throttle event object.");
 static PyMemberDef pyrf_throttle_event__members[] = {
 	sample_members
 	member_def(perf_event_header, type, T_UINT, "event type"),
 	member_def(throttle_event, time, T_ULONGLONG, "timestamp"),
 	member_def(throttle_event, id, T_ULONGLONG, "event id"),
 	member_def(throttle_event, stream_id, T_ULONGLONG, "event stream id"),
 	{ .name = NULL, },
 };
 static PyObject *pyrf_throttle_event__repr(struct pyrf_event *pevent)
 {
 	struct throttle_event *te = (struct throttle_event *)(&pevent->event.header + 1);
 	return PyString_FromFormat("{ type: %sthrottle, time: %" PRIu64 ", id: %" PRIu64
 				   ", stream_id: %" PRIu64 " }",
 				   pevent->event.header.type == PERF_RECORD_THROTTLE ? "" : "un",
 				   te->time, te->id, te->stream_id);
 }
 static PyTypeObject pyrf_throttle_event__type = {
 	PyVarObject_HEAD_INIT(NULL, 0)
 	.tp_name	= "perf.throttle_event",
 	.tp_basicsize	= sizeof(struct pyrf_event),
 	.tp_flags	= Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE,
 	.tp_doc		= pyrf_throttle_event__doc,
 	.tp_members	= pyrf_throttle_event__members,
 	.tp_repr	= (reprfunc)pyrf_throttle_event__repr,
 };
+static char pyrf_lost_event__doc[] = PyDoc_STR("perf lost event object.");
+static PyMemberDef pyrf_lost_event__members[] = {
+	sample_members
+	member_def(lost_event, id, T_ULONGLONG, "event id"),
+	member_def(lost_event, lost, T_ULONGLONG, "number of lost events"),
+	{ .name = NULL, },
+};
+static PyObject *pyrf_lost_event__repr(struct pyrf_event *pevent)
+{
+	PyObject *ret;
+	char *s;
+	if (asprintf(&s, "{ type: lost, id: %#" PRIx64 ", "
+			 "lost: %#" PRIx64 " }",
+		     pevent->event.lost.id, pevent->event.lost.lost) < 0) {
+		ret = PyErr_NoMemory();
+	} else {
+		ret = PyString_FromString(s);
+		free(s);
+	}
+	return ret;
+}
+static PyTypeObject pyrf_lost_event__type = {
+	PyVarObject_HEAD_INIT(NULL, 0)
+	.tp_name	= "perf.lost_event",
+	.tp_basicsize	= sizeof(struct pyrf_event),
+	.tp_flags	= Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE,
+	.tp_doc		= pyrf_lost_event__doc,
+	.tp_members	= pyrf_lost_event__members,
+	.tp_repr	= (reprfunc)pyrf_lost_event__repr,
+};
+static char pyrf_read_event__doc[] = PyDoc_STR("perf read event object.");
+static PyMemberDef pyrf_read_event__members[] = {
+	sample_members
+	member_def(read_event, pid, T_UINT, "event pid"),
+	member_def(read_event, tid, T_UINT, "event tid"),
+	{ .name = NULL, },
+};
+static PyObject *pyrf_read_event__repr(struct pyrf_event *pevent)
+{
+	return PyString_FromFormat("{ type: read, pid: %u, tid: %u }",
+				   pevent->event.read.pid,
+				   pevent->event.read.tid);
+	/*
+ 	 * FIXME: return the array of read values,
+ 	 * making this method useful ;-)
+ 	 */
+}
+static PyTypeObject pyrf_read_event__type = {
+	PyVarObject_HEAD_INIT(NULL, 0)
+	.tp_name	= "perf.read_event",
+	.tp_basicsize	= sizeof(struct pyrf_event),
+	.tp_flags	= Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE,
+	.tp_doc		= pyrf_read_event__doc,
+	.tp_members	= pyrf_read_event__members,
+	.tp_repr	= (reprfunc)pyrf_read_event__repr,
+};
+static char pyrf_sample_event__doc[] = PyDoc_STR("perf sample event object.");
+static PyMemberDef pyrf_sample_event__members[] = {
+	sample_members
+	member_def(perf_event_header, type, T_UINT, "event type"),
+	{ .name = NULL, },
+};
+static PyObject *pyrf_sample_event__repr(struct pyrf_event *pevent)
+{
+	PyObject *ret;
+	char *s;
+	if (asprintf(&s, "{ type: sample }") < 0) {
+		ret = PyErr_NoMemory();
+	} else {
+		ret = PyString_FromString(s);
+		free(s);
+	}
+	return ret;
+}
+static PyTypeObject pyrf_sample_event__type = {
+	PyVarObject_HEAD_INIT(NULL, 0)
+	.tp_name	= "perf.sample_event",
+	.tp_basicsize	= sizeof(struct pyrf_event),
+	.tp_flags	= Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE,
+	.tp_doc		= pyrf_sample_event__doc,
+	.tp_members	= pyrf_sample_event__members,
+	.tp_repr	= (reprfunc)pyrf_sample_event__repr,
+};
 static int pyrf_event__setup_types(void)
 {
 	int err;
 	pyrf_mmap_event__type.tp_new =
 	pyrf_task_event__type.tp_new =
 	pyrf_comm_event__type.tp_new =
+	pyrf_lost_event__type.tp_new =
+	pyrf_read_event__type.tp_new =
+	pyrf_sample_event__type.tp_new =
 	pyrf_throttle_event__type.tp_new = PyType_GenericNew;
 	err = PyType_Ready(&pyrf_mmap_event__type);
 	if (err < 0)
 		goto out;
+	err = PyType_Ready(&pyrf_lost_event__type);
+	if (err < 0)
+		goto out;
 	err = PyType_Ready(&pyrf_task_event__type);
 	if (err < 0)
 		goto out;
 	err = PyType_Ready(&pyrf_comm_event__type);
 	if (err < 0)
 		goto out;
 	err = PyType_Ready(&pyrf_throttle_event__type);
 	if (err < 0)
 		goto out;
+	err = PyType_Ready(&pyrf_read_event__type);
+	if (err < 0)
+		goto out;
+	err = PyType_Ready(&pyrf_sample_event__type);
+	if (err < 0)
+		goto out;
 out:
 	return err;
 }
 static PyTypeObject *pyrf_event__type[] = {
 	[PERF_RECORD_MMAP]	 = &pyrf_mmap_event__type,
-	[PERF_RECORD_LOST]	 = &pyrf_mmap_event__type,
+	[PERF_RECORD_LOST]	 = &pyrf_lost_event__type,
 	[PERF_RECORD_COMM]	 = &pyrf_comm_event__type,
 	[PERF_RECORD_EXIT]	 = &pyrf_task_event__type,
 	[PERF_RECORD_THROTTLE]	 = &pyrf_throttle_event__type,
 	[PERF_RECORD_UNTHROTTLE] = &pyrf_throttle_event__type,
 	[PERF_RECORD_FORK]	 = &pyrf_task_event__type,
-	[PERF_RECORD_READ]	 = &pyrf_mmap_event__type,
+	[PERF_RECORD_READ]	 = &pyrf_read_event__type,
-	[PERF_RECORD_SAMPLE]	 = &pyrf_mmap_event__type,
+	[PERF_RECORD_SAMPLE]	 = &pyrf_sample_event__type,
 };
 static PyObject *pyrf_event__new(union perf_event *event)
 {
 	struct pyrf_event *pevent;
 	PyTypeObject *ptype;
 	if (event->header.type < PERF_RECORD_MMAP ||
 	    event->header.type > PERF_RECORD_SAMPLE)
 		return NULL;
 	ptype = pyrf_event__type[event->header.type];
 	pevent = PyObject_New(struct pyrf_event, ptype);
 	if (pevent != NULL)
 		memcpy(&pevent->event, event, event->header.size);
 	return (PyObject *)pevent;
 }
 struct pyrf_cpu_map {
 	PyObject_HEAD
 	struct cpu_map *cpus;
 };
 static int pyrf_cpu_map__init(struct pyrf_cpu_map *pcpus,
 			      PyObject *args, PyObject *kwargs)
 {
 	static char *kwlist[] = { "cpustr", NULL };
 	char *cpustr = NULL;
 	if (!PyArg_ParseTupleAndKeywords(args, kwargs, "|s",
 					 kwlist, &cpustr))
 		return -1;
 	pcpus->cpus = cpu_map__new(cpustr);
 	if (pcpus->cpus == NULL)
 		return -1;
 	return 0;
 }
 static void pyrf_cpu_map__delete(struct pyrf_cpu_map *pcpus)
 {
 	cpu_map__delete(pcpus->cpus);
 	pcpus->ob_type->tp_free((PyObject*)pcpus);
 }
 static Py_ssize_t pyrf_cpu_map__length(PyObject *obj)
 {
 	struct pyrf_cpu_map *pcpus = (void *)obj;
 	return pcpus->cpus->nr;
 }
 static PyObject *pyrf_cpu_map__item(PyObject *obj, Py_ssize_t i)
 {
 	struct pyrf_cpu_map *pcpus = (void *)obj;
 	if (i >= pcpus->cpus->nr)
 		return NULL;
 	return Py_BuildValue("i", pcpus->cpus->map[i]);
 }
 static PySequenceMethods pyrf_cpu_map__sequence_methods = {
 	.sq_length = pyrf_cpu_map__length,
 	.sq_item   = pyrf_cpu_map__item,
 };
 static char pyrf_cpu_map__doc[] = PyDoc_STR("cpu map object.");
 static PyTypeObject pyrf_cpu_map__type = {
 	PyVarObject_HEAD_INIT(NULL, 0)
 	.tp_name	= "perf.cpu_map",
 	.tp_basicsize	= sizeof(struct pyrf_cpu_map),
 	.tp_dealloc	= (destructor)pyrf_cpu_map__delete,
 	.tp_flags	= Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE,
 	.tp_doc		= pyrf_cpu_map__doc,
 	.tp_as_sequence	= &pyrf_cpu_map__sequence_methods,
 	.tp_init	= (initproc)pyrf_cpu_map__init,
 };
 static int pyrf_cpu_map__setup_types(void)
 {
 	pyrf_cpu_map__type.tp_new = PyType_GenericNew;
 	return PyType_Ready(&pyrf_cpu_map__type);
 }
 struct pyrf_thread_map {
 	PyObject_HEAD
 	struct thread_map *threads;
 };
 static int pyrf_thread_map__init(struct pyrf_thread_map *pthreads,
 				 PyObject *args, PyObject *kwargs)
 {
 	static char *kwlist[] = { "pid", "tid", NULL };
 	int pid = -1, tid = -1;
 	if (!PyArg_ParseTupleAndKeywords(args, kwargs, "|ii",
 					 kwlist, &pid, &tid))
 		return -1;
 	pthreads->threads = thread_map__new(pid, tid);
 	if (pthreads->threads == NULL)
 		return -1;
 	return 0;
 }
 static void pyrf_thread_map__delete(struct pyrf_thread_map *pthreads)
 {
 	thread_map__delete(pthreads->threads);
 	pthreads->ob_type->tp_free((PyObject*)pthreads);
 }
 static Py_ssize_t pyrf_thread_map__length(PyObject *obj)
 {
 	struct pyrf_thread_map *pthreads = (void *)obj;
 	return pthreads->threads->nr;
 }
 static PyObject *pyrf_thread_map__item(PyObject *obj, Py_ssize_t i)
 {
 	struct pyrf_thread_map *pthreads = (void *)obj;
 	if (i >= pthreads->threads->nr)
 		return NULL;
 	return Py_BuildValue("i", pthreads->threads->map[i]);
 }
 static PySequenceMethods pyrf_thread_map__sequence_methods = {
 	.sq_length = pyrf_thread_map__length,
 	.sq_item   = pyrf_thread_map__item,
 };
 static char pyrf_thread_map__doc[] = PyDoc_STR("thread map object.");
 static PyTypeObject pyrf_thread_map__type = {
 	PyVarObject_HEAD_INIT(NULL, 0)
 	.tp_name	= "perf.thread_map",
 	.tp_basicsize	= sizeof(struct pyrf_thread_map),
 	.tp_dealloc	= (destructor)pyrf_thread_map__delete,
 	.tp_flags	= Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE,
 	.tp_doc		= pyrf_thread_map__doc,
 	.tp_as_sequence	= &pyrf_thread_map__sequence_methods,
 	.tp_init	= (initproc)pyrf_thread_map__init,
 };
 static int pyrf_thread_map__setup_types(void)
 {
 	pyrf_thread_map__type.tp_new = PyType_GenericNew;
 	return PyType_Ready(&pyrf_thread_map__type);
 }
 struct pyrf_evsel {
 	PyObject_HEAD
 	struct perf_evsel evsel;
 };
 static int pyrf_evsel__init(struct pyrf_evsel *pevsel,
 			    PyObject *args, PyObject *kwargs)
 {
 	struct perf_event_attr attr = {
 		.type = PERF_TYPE_HARDWARE,
 		.config = PERF_COUNT_HW_CPU_CYCLES,
 		.sample_type = PERF_SAMPLE_PERIOD | PERF_SAMPLE_TID,
 	};
 	static char *kwlist[] = {
 		"type",
 		"config",
 		"sample_freq",
 		"sample_period",
 		"sample_type",
 		"read_format",
 		"disabled",
 		"inherit",
 		"pinned",
 		"exclusive",
 		"exclude_user",
 		"exclude_kernel",
 		"exclude_hv",
 		"exclude_idle",
 		"mmap",
 		"comm",
 		"freq",
 		"inherit_stat",
 		"enable_on_exec",
 		"task",
 		"watermark",
 		"precise_ip",
 		"mmap_data",
 		"sample_id_all",
 		"wakeup_events",
 		"bp_type",
 		"bp_addr",
 		"bp_len",
 		 NULL
 	};
 	u64 sample_period = 0;
 	u32 disabled = 0,
 	    inherit = 0,
 	    pinned = 0,
 	    exclusive = 0,
 	    exclude_user = 0,
 	    exclude_kernel = 0,
 	    exclude_hv = 0,
 	    exclude_idle = 0,
 	    mmap = 0,
 	    comm = 0,
 	    freq = 1,
 	    inherit_stat = 0,
 	    enable_on_exec = 0,
 	    task = 0,
 	    watermark = 0,
 	    precise_ip = 0,
 	    mmap_data = 0,
 	    sample_id_all = 1;
 	int idx = 0;
 	if (!PyArg_ParseTupleAndKeywords(args, kwargs,
 					 "|iKiKKiiiiiiiiiiiiiiiiiiiiiKK", kwlist,
 					 &attr.type, &attr.config, &attr.sample_freq,
 					 &sample_period, &attr.sample_type,
 					 &attr.read_format, &disabled, &inherit,
 					 &pinned, &exclusive, &exclude_user,
 					 &exclude_kernel, &exclude_hv, &exclude_idle,
 					 &mmap, &comm, &freq, &inherit_stat,
 					 &enable_on_exec, &task, &watermark,
 					 &precise_ip, &mmap_data, &sample_id_all,
 					 &attr.wakeup_events, &attr.bp_type,
 					 &attr.bp_addr, &attr.bp_len, &idx))
 		return -1;
 	/* union... */
 	if (sample_period != 0) {
 		if (attr.sample_freq != 0)
 			return -1; /* FIXME: throw right exception */
 		attr.sample_period = sample_period;
 	}
 	/* Bitfields */
 	attr.disabled	    = disabled;
 	attr.inherit	    = inherit;
 	attr.pinned	    = pinned;
 	attr.exclusive	    = exclusive;
 	attr.exclude_user   = exclude_user;
 	attr.exclude_kernel = exclude_kernel;
 	attr.exclude_hv	    = exclude_hv;
 	attr.exclude_idle   = exclude_idle;
 	attr.mmap	    = mmap;
 	attr.comm	    = comm;
 	attr.freq	    = freq;
 	attr.inherit_stat   = inherit_stat;
 	attr.enable_on_exec = enable_on_exec;
 	attr.task	    = task;
 	attr.watermark	    = watermark;
 	attr.precise_ip	    = precise_ip;
 	attr.mmap_data	    = mmap_data;
 	attr.sample_id_all  = sample_id_all;
 	perf_evsel__init(&pevsel->evsel, &attr, idx);
 	return 0;
 }
 static void pyrf_evsel__delete(struct pyrf_evsel *pevsel)
 {
 	perf_evsel__exit(&pevsel->evsel);
 	pevsel->ob_type->tp_free((PyObject*)pevsel);
 }
 static PyObject *pyrf_evsel__open(struct pyrf_evsel *pevsel,
 				  PyObject *args, PyObject *kwargs)
 {
 	struct perf_evsel *evsel = &pevsel->evsel;
 	struct cpu_map *cpus = NULL;
 	struct thread_map *threads = NULL;
 	PyObject *pcpus = NULL, *pthreads = NULL;
 	int group = 0, inherit = 0;
 	static char *kwlist[] = { "cpus", "threads", "group", "inherit", NULL };
 	if (!PyArg_ParseTupleAndKeywords(args, kwargs, "|OOii", kwlist,
 					 &pcpus, &pthreads, &group, &inherit))
 		return NULL;
 	if (pthreads != NULL)
 		threads = ((struct pyrf_thread_map *)pthreads)->threads;
 	if (pcpus != NULL)
 		cpus = ((struct pyrf_cpu_map *)pcpus)->cpus;
 	evsel->attr.inherit = inherit;
 	if (perf_evsel__open(evsel, cpus, threads, group) < 0) {
 		PyErr_SetFromErrno(PyExc_OSError);
 		return NULL;
 	}
 	Py_INCREF(Py_None);
 	return Py_None;
 }
 static PyMethodDef pyrf_evsel__methods[] = {
 	{
 		.ml_name  = "open",
 		.ml_meth  = (PyCFunction)pyrf_evsel__open,
 		.ml_flags = METH_VARARGS | METH_KEYWORDS,
 		.ml_doc	  = PyDoc_STR("open the event selector file descriptor table.")
 	},
 	{ .ml_name = NULL, }
 };
 static char pyrf_evsel__doc[] = PyDoc_STR("perf event selector list object.");
 static PyTypeObject pyrf_evsel__type = {
 	PyVarObject_HEAD_INIT(NULL, 0)
 	.tp_name	= "perf.evsel",
 	.tp_basicsize	= sizeof(struct pyrf_evsel),
 	.tp_dealloc	= (destructor)pyrf_evsel__delete,
 	.tp_flags	= Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE,
 	.tp_doc		= pyrf_evsel__doc,
 	.tp_methods	= pyrf_evsel__methods,
 	.tp_init	= (initproc)pyrf_evsel__init,
 };
 static int pyrf_evsel__setup_types(void)
 {
 	pyrf_evsel__type.tp_new = PyType_GenericNew;
 	return PyType_Ready(&pyrf_evsel__type);
 }
 struct pyrf_evlist {
 	PyObject_HEAD
 	struct perf_evlist evlist;
 };
 static int pyrf_evlist__init(struct pyrf_evlist *pevlist,
 			     PyObject *args, PyObject *kwargs __used)
 {
 	PyObject *pcpus = NULL, *pthreads = NULL;
 	struct cpu_map *cpus;
 	struct thread_map *threads;
 	if (!PyArg_ParseTuple(args, "OO", &pcpus, &pthreads))
 		return -1;
 	threads = ((struct pyrf_thread_map *)pthreads)->threads;
 	cpus = ((struct pyrf_cpu_map *)pcpus)->cpus;
 	perf_evlist__init(&pevlist->evlist, cpus, threads);
 	return 0;
 }
 static void pyrf_evlist__delete(struct pyrf_evlist *pevlist)
 {
 	perf_evlist__exit(&pevlist->evlist);
 	pevlist->ob_type->tp_free((PyObject*)pevlist);
 }
 static PyObject *pyrf_evlist__mmap(struct pyrf_evlist *pevlist,
 				   PyObject *args, PyObject *kwargs)
 {
 	struct perf_evlist *evlist = &pevlist->evlist;
 	static char *kwlist[] = { "pages", "overwrite", NULL };
 	int pages = 128, overwrite = false;
 	if (!PyArg_ParseTupleAndKeywords(args, kwargs, "|ii", kwlist,
 					 &pages, &overwrite))
 		return NULL;
 	if (perf_evlist__mmap(evlist, pages, overwrite) < 0) {
 		PyErr_SetFromErrno(PyExc_OSError);
 		return NULL;
 	}
 	Py_INCREF(Py_None);
 	return Py_None;
 }
 static PyObject *pyrf_evlist__poll(struct pyrf_evlist *pevlist,
 				   PyObject *args, PyObject *kwargs)
 {
 	struct perf_evlist *evlist = &pevlist->evlist;
 	static char *kwlist[] = { "timeout", NULL };
 	int timeout = -1, n;
 	if (!PyArg_ParseTupleAndKeywords(args, kwargs, "|i", kwlist, &timeout))
 		return NULL;
 	n = poll(evlist->pollfd, evlist->nr_fds, timeout);
 	if (n < 0) {
 		PyErr_SetFromErrno(PyExc_OSError);
 		return NULL;
 	}
 	return Py_BuildValue("i", n);
 }
 static PyObject *pyrf_evlist__get_pollfd(struct pyrf_evlist *pevlist,
 					 PyObject *args __used, PyObject *kwargs __used)
 {
 	struct perf_evlist *evlist = &pevlist->evlist;
         PyObject *list = PyList_New(0);
 	int i;
 	for (i = 0; i < evlist->nr_fds; ++i) {
 		PyObject *file;
 		FILE *fp = fdopen(evlist->pollfd[i].fd, "r");
 		if (fp == NULL)
 			goto free_list;
 		file = PyFile_FromFile(fp, "perf", "r", NULL);
 		if (file == NULL)
 			goto free_list;
 		if (PyList_Append(list, file) != 0) {
 			Py_DECREF(file);
 			goto free_list;
 		}
 		Py_DECREF(file);
 	}
 	return list;
 free_list:
 	return PyErr_NoMemory();
 }
 static PyObject *pyrf_evlist__add(struct pyrf_evlist *pevlist,
 				  PyObject *args, PyObject *kwargs __used)
 {
 	struct perf_evlist *evlist = &pevlist->evlist;
 	PyObject *pevsel;
 	struct perf_evsel *evsel;
 	if (!PyArg_ParseTuple(args, "O", &pevsel))
 		return NULL;
 	Py_INCREF(pevsel);
 	evsel = &((struct pyrf_evsel *)pevsel)->evsel;
 	evsel->idx = evlist->nr_entries;
 	perf_evlist__add(evlist, evsel);
 	return Py_BuildValue("i", evlist->nr_entries);
 }
 static PyObject *pyrf_evlist__read_on_cpu(struct pyrf_evlist *pevlist,
 					  PyObject *args, PyObject *kwargs)
 {
 	struct perf_evlist *evlist = &pevlist->evlist;
 	union perf_event *event;
 	int sample_id_all = 1, cpu;
 	static char *kwlist[] = { "cpu", "sample_id_all", NULL };
 	int err;
 	if (!PyArg_ParseTupleAndKeywords(args, kwargs, "i|i", kwlist,
 					 &cpu, &sample_id_all))
 		return NULL;
 	event = perf_evlist__mmap_read(evlist, cpu);
 	if (event != NULL) {
 		struct perf_evsel *first;
 		PyObject *pyevent = pyrf_event__new(event);
 		struct pyrf_event *pevent = (struct pyrf_event *)pyevent;
 		if (pyevent == NULL)
 			return PyErr_NoMemory();
 		first = list_entry(evlist->entries.next, struct perf_evsel, node);
 		err = perf_event__parse_sample(event, first->attr.sample_type,
 					       perf_evsel__sample_size(first),
 					       sample_id_all, &pevent->sample);
 		if (err)
 			return PyErr_Format(PyExc_OSError,
 					    "perf: can't parse sample, err=%d", err);
 		return pyevent;
 	}
 	Py_INCREF(Py_None);
 	return Py_None;
 }
 static PyMethodDef pyrf_evlist__methods[] = {
 	{
 		.ml_name  = "mmap",
 		.ml_meth  = (PyCFunction)pyrf_evlist__mmap,
 		.ml_flags = METH_VARARGS | METH_KEYWORDS,
 		.ml_doc	  = PyDoc_STR("mmap the file descriptor table.")
 	},
 	{
 		.ml_name  = "poll",
 		.ml_meth  = (PyCFunction)pyrf_evlist__poll,
 		.ml_flags = METH_VARARGS | METH_KEYWORDS,
 		.ml_doc	  = PyDoc_STR("poll the file descriptor table.")
 	},
 	{
 		.ml_name  = "get_pollfd",
 		.ml_meth  = (PyCFunction)pyrf_evlist__get_pollfd,
 		.ml_flags = METH_VARARGS | METH_KEYWORDS,
 		.ml_doc	  = PyDoc_STR("get the poll file descriptor table.")
 	},
 	{
 		.ml_name  = "add",
 		.ml_meth  = (PyCFunction)pyrf_evlist__add,
 		.ml_flags = METH_VARARGS | METH_KEYWORDS,
 		.ml_doc	  = PyDoc_STR("adds an event selector to the list.")
 	},
 	{
 		.ml_name  = "read_on_cpu",
 		.ml_meth  = (PyCFunction)pyrf_evlist__read_on_cpu,
 		.ml_flags = METH_VARARGS | METH_KEYWORDS,
 		.ml_doc	  = PyDoc_STR("reads an event.")
 	},
 	{ .ml_name = NULL, }
 };
 static Py_ssize_t pyrf_evlist__length(PyObject *obj)
 {
 	struct pyrf_evlist *pevlist = (void *)obj;
 	return pevlist->evlist.nr_entries;
 }
 static PyObject *pyrf_evlist__item(PyObject *obj, Py_ssize_t i)
 {
 	struct pyrf_evlist *pevlist = (void *)obj;
 	struct perf_evsel *pos;
 	if (i >= pevlist->evlist.nr_entries)
 		return NULL;
 	list_for_each_entry(pos, &pevlist->evlist.entries, node)
 		if (i-- == 0)
 			break;
 	return Py_BuildValue("O", container_of(pos, struct pyrf_evsel, evsel));
 }
 static PySequenceMethods pyrf_evlist__sequence_methods = {
 	.sq_length = pyrf_evlist__length,
 	.sq_item   = pyrf_evlist__item,
 };
 static char pyrf_evlist__doc[] = PyDoc_STR("perf event selector list object.");
 static PyTypeObject pyrf_evlist__type = {
 	PyVarObject_HEAD_INIT(NULL, 0)
 	.tp_name	= "perf.evlist",
 	.tp_basicsize	= sizeof(struct pyrf_evlist),
 	.tp_dealloc	= (destructor)pyrf_evlist__delete,
 	.tp_flags	= Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE,
 	.tp_as_sequence	= &pyrf_evlist__sequence_methods,
 	.tp_doc		= pyrf_evlist__doc,
 	.tp_methods	= pyrf_evlist__methods,
 	.tp_init	= (initproc)pyrf_evlist__init,
 };
 static int pyrf_evlist__setup_types(void)
 {
 	pyrf_evlist__type.tp_new = PyType_GenericNew;
 	return PyType_Ready(&pyrf_evlist__type);
 }
 static struct {
 	const char *name;
 	int	    value;
 } perf__constants[] = {
 	{ "TYPE_HARDWARE",   PERF_TYPE_HARDWARE },
 	{ "TYPE_SOFTWARE",   PERF_TYPE_SOFTWARE },
 	{ "TYPE_TRACEPOINT", PERF_TYPE_TRACEPOINT },
 	{ "TYPE_HW_CACHE",   PERF_TYPE_HW_CACHE },
 	{ "TYPE_RAW",	     PERF_TYPE_RAW },
 	{ "TYPE_BREAKPOINT", PERF_TYPE_BREAKPOINT },
 	{ "COUNT_HW_CPU_CYCLES",	  PERF_COUNT_HW_CPU_CYCLES },
 	{ "COUNT_HW_INSTRUCTIONS",	  PERF_COUNT_HW_INSTRUCTIONS },
 	{ "COUNT_HW_CACHE_REFERENCES",	  PERF_COUNT_HW_CACHE_REFERENCES },
 	{ "COUNT_HW_CACHE_MISSES",	  PERF_COUNT_HW_CACHE_MISSES },
 	{ "COUNT_HW_BRANCH_INSTRUCTIONS", PERF_COUNT_HW_BRANCH_INSTRUCTIONS },
 	{ "COUNT_HW_BRANCH_MISSES",	  PERF_COUNT_HW_BRANCH_MISSES },
 	{ "COUNT_HW_BUS_CYCLES",	  PERF_COUNT_HW_BUS_CYCLES },
 	{ "COUNT_HW_CACHE_L1D",		  PERF_COUNT_HW_CACHE_L1D },
 	{ "COUNT_HW_CACHE_L1I",		  PERF_COUNT_HW_CACHE_L1I },
 	{ "COUNT_HW_CACHE_LL",	  	  PERF_COUNT_HW_CACHE_LL },
 	{ "COUNT_HW_CACHE_DTLB",	  PERF_COUNT_HW_CACHE_DTLB },
 	{ "COUNT_HW_CACHE_ITLB",	  PERF_COUNT_HW_CACHE_ITLB },
 	{ "COUNT_HW_CACHE_BPU",		  PERF_COUNT_HW_CACHE_BPU },
 	{ "COUNT_HW_CACHE_OP_READ",	  PERF_COUNT_HW_CACHE_OP_READ },
 	{ "COUNT_HW_CACHE_OP_WRITE",	  PERF_COUNT_HW_CACHE_OP_WRITE },
 	{ "COUNT_HW_CACHE_OP_PREFETCH",	  PERF_COUNT_HW_CACHE_OP_PREFETCH },
 	{ "COUNT_HW_CACHE_RESULT_ACCESS", PERF_COUNT_HW_CACHE_RESULT_ACCESS },
 	{ "COUNT_HW_CACHE_RESULT_MISS",   PERF_COUNT_HW_CACHE_RESULT_MISS },
 	{ "COUNT_HW_STALLED_CYCLES_FRONTEND",	  PERF_COUNT_HW_STALLED_CYCLES_FRONTEND },
 	{ "COUNT_HW_STALLED_CYCLES_BACKEND",	  PERF_COUNT_HW_STALLED_CYCLES_BACKEND },
 	{ "COUNT_SW_CPU_CLOCK",	       PERF_COUNT_SW_CPU_CLOCK },
 	{ "COUNT_SW_TASK_CLOCK",       PERF_COUNT_SW_TASK_CLOCK },
 	{ "COUNT_SW_PAGE_FAULTS",      PERF_COUNT_SW_PAGE_FAULTS },
 	{ "COUNT_SW_CONTEXT_SWITCHES", PERF_COUNT_SW_CONTEXT_SWITCHES },
 	{ "COUNT_SW_CPU_MIGRATIONS",   PERF_COUNT_SW_CPU_MIGRATIONS },
 	{ "COUNT_SW_PAGE_FAULTS_MIN",  PERF_COUNT_SW_PAGE_FAULTS_MIN },
 	{ "COUNT_SW_PAGE_FAULTS_MAJ",  PERF_COUNT_SW_PAGE_FAULTS_MAJ },
 	{ "COUNT_SW_ALIGNMENT_FAULTS", PERF_COUNT_SW_ALIGNMENT_FAULTS },
 	{ "COUNT_SW_EMULATION_FAULTS", PERF_COUNT_SW_EMULATION_FAULTS },
 	{ "SAMPLE_IP",	      PERF_SAMPLE_IP },
 	{ "SAMPLE_TID",	      PERF_SAMPLE_TID },
 	{ "SAMPLE_TIME",      PERF_SAMPLE_TIME },
 	{ "SAMPLE_ADDR",      PERF_SAMPLE_ADDR },
 	{ "SAMPLE_READ",      PERF_SAMPLE_READ },
 	{ "SAMPLE_CALLCHAIN", PERF_SAMPLE_CALLCHAIN },
 	{ "SAMPLE_ID",	      PERF_SAMPLE_ID },
 	{ "SAMPLE_CPU",	      PERF_SAMPLE_CPU },
 	{ "SAMPLE_PERIOD",    PERF_SAMPLE_PERIOD },
 	{ "SAMPLE_STREAM_ID", PERF_SAMPLE_STREAM_ID },
 	{ "SAMPLE_RAW",	      PERF_SAMPLE_RAW },
 	{ "FORMAT_TOTAL_TIME_ENABLED", PERF_FORMAT_TOTAL_TIME_ENABLED },
 	{ "FORMAT_TOTAL_TIME_RUNNING", PERF_FORMAT_TOTAL_TIME_RUNNING },
 	{ "FORMAT_ID",		       PERF_FORMAT_ID },
 	{ "FORMAT_GROUP",	       PERF_FORMAT_GROUP },
 	{ "RECORD_MMAP",       PERF_RECORD_MMAP },
 	{ "RECORD_LOST",       PERF_RECORD_LOST },
 	{ "RECORD_COMM",       PERF_RECORD_COMM },
 	{ "RECORD_EXIT",       PERF_RECORD_EXIT },
 	{ "RECORD_THROTTLE",   PERF_RECORD_THROTTLE },
 	{ "RECORD_UNTHROTTLE", PERF_RECORD_UNTHROTTLE },
 	{ "RECORD_FORK",       PERF_RECORD_FORK },
 	{ "RECORD_READ",       PERF_RECORD_READ },
 	{ "RECORD_SAMPLE",     PERF_RECORD_SAMPLE },
 	{ .name = NULL, },
 };
 static PyMethodDef perf__methods[] = {
 	{ .ml_name = NULL, }
 };
 PyMODINIT_FUNC initperf(void)
 {
 	PyObject *obj;
 	int i;
 	PyObject *dict, *module = Py_InitModule("perf", perf__methods);
 	if (module == NULL ||
 	    pyrf_event__setup_types() < 0 ||
 	    pyrf_evlist__setup_types() < 0 ||
 	    pyrf_evsel__setup_types() < 0 ||
 	    pyrf_thread_map__setup_types() < 0 ||
 	    pyrf_cpu_map__setup_types() < 0)
 		return;
 	Py_INCREF(&pyrf_evlist__type);
 	PyModule_AddObject(module, "evlist", (PyObject*)&pyrf_evlist__type);
 	Py_INCREF(&pyrf_evsel__type);
 	PyModule_AddObject(module, "evsel", (PyObject*)&pyrf_evsel__type);
 	Py_INCREF(&pyrf_thread_map__type);
 	PyModule_AddObject(module, "thread_map", (PyObject*)&pyrf_thread_map__type);
 	Py_INCREF(&pyrf_cpu_map__type);
 	PyModule_AddObject(module, "cpu_map", (PyObject*)&pyrf_cpu_map__type);
 	dict = PyModule_GetDict(module);
 	if (dict == NULL)
 		goto error;
 	for (i = 0; perf__constants[i].name != NULL; i++) {
 		obj = PyInt_FromLong(perf__constants[i].value);
 		if (obj == NULL)
 			goto error;
 		PyDict_SetItemString(dict, perf__constants[i].name, obj);
 		Py_DECREF(obj);
 	}
 error:
 	if (PyErr_Occurred())
 		PyErr_SetString(PyExc_ImportError, "perf: Init failed!");
 }

tools/perf/util/setup.py

Diff comments View file @ 1d229d5

 #!/usr/bin/python2
 from distutils.core import setup, Extension
 from os import getenv
+from distutils.command.build_ext   import build_ext   as _build_ext
+from distutils.command.install_lib import install_lib as _install_lib
+class build_ext(_build_ext):
+    def finalize_options(self):
+        _build_ext.finalize_options(self)
+        self.build_lib  = build_lib
+        self.build_temp = build_tmp
+class install_lib(_install_lib):
+    def finalize_options(self):
+        _install_lib.finalize_options(self)
+        self.build_dir = build_lib
 cflags = ['-fno-strict-aliasing', '-Wno-write-strings']
 cflags += getenv('CFLAGS', '').split()
+build_lib = getenv('PYTHON_EXTBUILD_LIB')
+build_tmp = getenv('PYTHON_EXTBUILD_TMP')
 perf = Extension('perf',
 		  sources = ['util/python.c', 'util/ctype.c', 'util/evlist.c',
 			     'util/evsel.c', 'util/cpumap.c', 'util/thread_map.c',
 			     'util/util.c', 'util/xyarray.c', 'util/cgroup.c'],
 		  include_dirs = ['util/include'],
 		  extra_compile_args = cflags,
                  )
 setup(name='perf',
       version='0.1',
       description='Interface with the Linux profiling infrastructure',
       author='Arnaldo Carvalho de Melo',
       author_email='acme@redhat.com',
       license='GPLv2',
       url='http://perf.wiki.kernel.org',
-      ext_modules=[perf])
+      ext_modules=[perf],
+      cmdclass={'build_ext': build_ext, 'install_lib': install_lib})

tools/perf/util/symbol.c

Diff comments View file @ 1d229d5

 #define _GNU_SOURCE
 #include <ctype.h>
 #include <dirent.h>
 #include <errno.h>
 #include <libgen.h>
 #include <stdlib.h>
 #include <stdio.h>
 #include <string.h>
 #include <sys/types.h>
 #include <sys/stat.h>
 #include <sys/param.h>
 #include <fcntl.h>
 #include <unistd.h>
 #include <inttypes.h>
 #include "build-id.h"
 #include "debug.h"
 #include "symbol.h"
 #include "strlist.h"
 #include <libelf.h>
 #include <gelf.h>
 #include <elf.h>
 #include <limits.h>
 #include <sys/utsname.h>
 #ifndef KSYM_NAME_LEN
 #define KSYM_NAME_LEN 128
 #endif
 #ifndef NT_GNU_BUILD_ID
 #define NT_GNU_BUILD_ID 3
 #endif
 static bool dso__build_id_equal(const struct dso *dso, u8 *build_id);
 static int elf_read_build_id(Elf *elf, void *bf, size_t size);
 static void dsos__add(struct list_head *head, struct dso *dso);
 static struct map *map__new2(u64 start, struct dso *dso, enum map_type type);
 static int dso__load_kernel_sym(struct dso *dso, struct map *map,
 				symbol_filter_t filter);
 static int dso__load_guest_kernel_sym(struct dso *dso, struct map *map,
 			symbol_filter_t filter);
 static int vmlinux_path__nr_entries;
 static char **vmlinux_path;
 struct symbol_conf symbol_conf = {
 	.exclude_other	  = true,
 	.use_modules	  = true,
 	.try_vmlinux_path = true,
 	.symfs            = "",
 };
 int dso__name_len(const struct dso *dso)
 {
 	if (verbose)
 		return dso->long_name_len;
 	return dso->short_name_len;
 }
 bool dso__loaded(const struct dso *dso, enum map_type type)
 {
 	return dso->loaded & (1 << type);
 }
 bool dso__sorted_by_name(const struct dso *dso, enum map_type type)
 {
 	return dso->sorted_by_name & (1 << type);
 }
 static void dso__set_sorted_by_name(struct dso *dso, enum map_type type)
 {
 	dso->sorted_by_name |= (1 << type);
 }
 bool symbol_type__is_a(char symbol_type, enum map_type map_type)
 {
 	switch (map_type) {
 	case MAP__FUNCTION:
 		return symbol_type == 'T' || symbol_type == 'W';
 	case MAP__VARIABLE:
 		return symbol_type == 'D' || symbol_type == 'd';
 	default:
 		return false;
 	}
 }
 static void symbols__fixup_end(struct rb_root *symbols)
 {
 	struct rb_node *nd, *prevnd = rb_first(symbols);
 	struct symbol *curr, *prev;
 	if (prevnd == NULL)
 		return;
 	curr = rb_entry(prevnd, struct symbol, rb_node);
 	for (nd = rb_next(prevnd); nd; nd = rb_next(nd)) {
 		prev = curr;
 		curr = rb_entry(nd, struct symbol, rb_node);
 		if (prev->end == prev->start && prev->end != curr->start)
 			prev->end = curr->start - 1;
 	}
 	/* Last entry */
 	if (curr->end == curr->start)
 		curr->end = roundup(curr->start, 4096);
 }
 static void __map_groups__fixup_end(struct map_groups *mg, enum map_type type)
 {
 	struct map *prev, *curr;
 	struct rb_node *nd, *prevnd = rb_first(&mg->maps[type]);
 	if (prevnd == NULL)
 		return;
 	curr = rb_entry(prevnd, struct map, rb_node);
 	for (nd = rb_next(prevnd); nd; nd = rb_next(nd)) {
 		prev = curr;
 		curr = rb_entry(nd, struct map, rb_node);
 		prev->end = curr->start - 1;
 	}
 	/*
 	 * We still haven't the actual symbols, so guess the
 	 * last map final address.
 	 */
 	curr->end = ~0ULL;
 }
 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 struct symbol *symbol__new(u64 start, u64 len, u8 binding,
 				  const char *name)
 {
 	size_t namelen = strlen(name) + 1;
 	struct symbol *sym = calloc(1, (symbol_conf.priv_size +
 					sizeof(*sym) + namelen));
 	if (sym == NULL)
 		return NULL;
 	if (symbol_conf.priv_size)
 		sym = ((void *)sym) + symbol_conf.priv_size;
 	sym->start   = start;
 	sym->end     = len ? start + len - 1 : start;
 	sym->binding = binding;
 	sym->namelen = namelen - 1;
 	pr_debug4("%s: %s %#" PRIx64 "-%#" PRIx64 "\n",
 		  __func__, name, start, sym->end);
 	memcpy(sym->name, name, namelen);
 	return sym;
 }
 void symbol__delete(struct symbol *sym)
 {
 	free(((void *)sym) - symbol_conf.priv_size);
 }
 static size_t symbol__fprintf(struct symbol *sym, FILE *fp)
 {
 	return fprintf(fp, " %" PRIx64 "-%" PRIx64 " %c %s\n",
 		       sym->start, sym->end,
 		       sym->binding == STB_GLOBAL ? 'g' :
 		       sym->binding == STB_LOCAL  ? 'l' : 'w',
 		       sym->name);
 }
 void dso__set_long_name(struct dso *dso, char *name)
 {
 	if (name == NULL)
 		return;
 	dso->long_name = name;
 	dso->long_name_len = strlen(name);
 }
 static void dso__set_short_name(struct dso *dso, const char *name)
 {
 	if (name == NULL)
 		return;
 	dso->short_name = name;
 	dso->short_name_len = strlen(name);
 }
 static void dso__set_basename(struct dso *dso)
 {
 	dso__set_short_name(dso, basename(dso->long_name));
 }
 struct dso *dso__new(const char *name)
 {
 	struct dso *dso = calloc(1, sizeof(*dso) + strlen(name) + 1);
 	if (dso != NULL) {
 		int i;
 		strcpy(dso->name, name);
 		dso__set_long_name(dso, dso->name);
 		dso__set_short_name(dso, dso->name);
 		for (i = 0; i < MAP__NR_TYPES; ++i)
 			dso->symbols[i] = dso->symbol_names[i] = RB_ROOT;
 		dso->symtab_type = SYMTAB__NOT_FOUND;
 		dso->loaded = 0;
 		dso->sorted_by_name = 0;
 		dso->has_build_id = 0;
 		dso->kernel = DSO_TYPE_USER;
 		INIT_LIST_HEAD(&dso->node);
 	}
 	return dso;
 }
 static void symbols__delete(struct rb_root *symbols)
 {
 	struct symbol *pos;
 	struct rb_node *next = rb_first(symbols);
 	while (next) {
 		pos = rb_entry(next, struct symbol, rb_node);
 		next = rb_next(&pos->rb_node);
 		rb_erase(&pos->rb_node, symbols);
 		symbol__delete(pos);
 	}
 }
 void dso__delete(struct dso *dso)
 {
 	int i;
 	for (i = 0; i < MAP__NR_TYPES; ++i)
 		symbols__delete(&dso->symbols[i]);
 	if (dso->sname_alloc)
 		free((char *)dso->short_name);
 	if (dso->lname_alloc)
 		free(dso->long_name);
 	free(dso);
 }
 void dso__set_build_id(struct dso *dso, void *build_id)
 {
 	memcpy(dso->build_id, build_id, sizeof(dso->build_id));
 	dso->has_build_id = 1;
 }
 static void symbols__insert(struct rb_root *symbols, struct symbol *sym)
 {
 	struct rb_node **p = &symbols->rb_node;
 	struct rb_node *parent = NULL;
 	const u64 ip = sym->start;
 	struct symbol *s;
 	while (*p != NULL) {
 		parent = *p;
 		s = rb_entry(parent, struct symbol, rb_node);
 		if (ip < s->start)
 			p = &(*p)->rb_left;
 		else
 			p = &(*p)->rb_right;
 	}
 	rb_link_node(&sym->rb_node, parent, p);
 	rb_insert_color(&sym->rb_node, symbols);
 }
 static struct symbol *symbols__find(struct rb_root *symbols, u64 ip)
 {
 	struct rb_node *n;
 	if (symbols == NULL)
 		return NULL;
 	n = symbols->rb_node;
 	while (n) {
 		struct symbol *s = rb_entry(n, struct symbol, rb_node);
 		if (ip < s->start)
 			n = n->rb_left;
 		else if (ip > s->end)
 			n = n->rb_right;
 		else
 			return s;
 	}
 	return NULL;
 }
 struct symbol_name_rb_node {
 	struct rb_node	rb_node;
 	struct symbol	sym;
 };
 static void symbols__insert_by_name(struct rb_root *symbols, struct symbol *sym)
 {
 	struct rb_node **p = &symbols->rb_node;
 	struct rb_node *parent = NULL;
 	struct symbol_name_rb_node *symn, *s;
 	symn = container_of(sym, struct symbol_name_rb_node, sym);
 	while (*p != NULL) {
 		parent = *p;
 		s = rb_entry(parent, struct symbol_name_rb_node, rb_node);
 		if (strcmp(sym->name, s->sym.name) < 0)
 			p = &(*p)->rb_left;
 		else
 			p = &(*p)->rb_right;
 	}
 	rb_link_node(&symn->rb_node, parent, p);
 	rb_insert_color(&symn->rb_node, symbols);
 }
 static void symbols__sort_by_name(struct rb_root *symbols,
 				  struct rb_root *source)
 {
 	struct rb_node *nd;
 	for (nd = rb_first(source); nd; nd = rb_next(nd)) {
 		struct symbol *pos = rb_entry(nd, struct symbol, rb_node);
 		symbols__insert_by_name(symbols, pos);
 	}
 }
 static struct symbol *symbols__find_by_name(struct rb_root *symbols,
 					    const char *name)
 {
 	struct rb_node *n;
 	if (symbols == NULL)
 		return NULL;
 	n = symbols->rb_node;
 	while (n) {
 		struct symbol_name_rb_node *s;
 		int cmp;
 		s = rb_entry(n, struct symbol_name_rb_node, rb_node);
 		cmp = strcmp(name, s->sym.name);
 		if (cmp < 0)
 			n = n->rb_left;
 		else if (cmp > 0)
 			n = n->rb_right;
 		else
 			return &s->sym;
 	}
 	return NULL;
 }
 struct symbol *dso__find_symbol(struct dso *dso,
 				enum map_type type, u64 addr)
 {
 	return symbols__find(&dso->symbols[type], addr);
 }
 struct symbol *dso__find_symbol_by_name(struct dso *dso, enum map_type type,
 					const char *name)
 {
 	return symbols__find_by_name(&dso->symbol_names[type], name);
 }
 void dso__sort_by_name(struct dso *dso, enum map_type type)
 {
 	dso__set_sorted_by_name(dso, type);
 	return symbols__sort_by_name(&dso->symbol_names[type],
 				     &dso->symbols[type]);
 }
 int build_id__sprintf(const u8 *build_id, int len, char *bf)
 {
 	char *bid = bf;
 	const u8 *raw = build_id;
 	int i;
 	for (i = 0; i < len; ++i) {
 		sprintf(bid, "%02x", *raw);
 		++raw;
 		bid += 2;
 	}
 	return raw - build_id;
 }
 size_t dso__fprintf_buildid(struct dso *dso, FILE *fp)
 {
 	char sbuild_id[BUILD_ID_SIZE * 2 + 1];
 	build_id__sprintf(dso->build_id, sizeof(dso->build_id), sbuild_id);
 	return fprintf(fp, "%s", sbuild_id);
 }
 size_t dso__fprintf_symbols_by_name(struct dso *dso,
 				    enum map_type type, FILE *fp)
 {
 	size_t ret = 0;
 	struct rb_node *nd;
 	struct symbol_name_rb_node *pos;
 	for (nd = rb_first(&dso->symbol_names[type]); nd; nd = rb_next(nd)) {
 		pos = rb_entry(nd, struct symbol_name_rb_node, rb_node);
 		fprintf(fp, "%s\n", pos->sym.name);
 	}
 	return ret;
 }
 size_t dso__fprintf(struct dso *dso, enum map_type type, FILE *fp)
 {
 	struct rb_node *nd;
 	size_t ret = fprintf(fp, "dso: %s (", dso->short_name);
 	if (dso->short_name != dso->long_name)
 		ret += fprintf(fp, "%s, ", dso->long_name);
 	ret += fprintf(fp, "%s, %sloaded, ", map_type__name[type],
 		       dso->loaded ? "" : "NOT ");
 	ret += dso__fprintf_buildid(dso, fp);
 	ret += fprintf(fp, ")\n");
 	for (nd = rb_first(&dso->symbols[type]); nd; nd = rb_next(nd)) {
 		struct symbol *pos = rb_entry(nd, struct symbol, rb_node);
 		ret += symbol__fprintf(pos, fp);
 	}
 	return ret;
 }
 int kallsyms__parse(const char *filename, void *arg,
 		    int (*process_symbol)(void *arg, const char *name,
 					  char type, u64 start, u64 end))
 {
 	char *line = NULL;
 	size_t n;
 	int err = -1;
 	u64 prev_start = 0;
 	char prev_symbol_type = 0;
 	char *prev_symbol_name;
 	FILE *file = fopen(filename, "r");
 	if (file == NULL)
 		goto out_failure;
 	prev_symbol_name = malloc(KSYM_NAME_LEN);
 	if (prev_symbol_name == NULL)
 		goto out_close;
 	err = 0;
 	while (!feof(file)) {
 		u64 start;
 		int line_len, len;
 		char symbol_type;
 		char *symbol_name;
 		line_len = getline(&line, &n, file);
 		if (line_len < 0 || !line)
 			break;
 		line[--line_len] = '\0'; /* \n */
 		len = hex2u64(line, &start);
 		len++;
 		if (len + 2 >= line_len)
 			continue;
 		symbol_type = toupper(line[len]);
 		len += 2;
 		symbol_name = line + len;
 		len = line_len - len;
 		if (len >= KSYM_NAME_LEN) {
 			err = -1;
 			break;
 		}
 		if (prev_symbol_type) {
 			u64 end = start;
 			if (end != prev_start)
 				--end;
 			err = process_symbol(arg, prev_symbol_name,
 					     prev_symbol_type, prev_start, end);
 			if (err)
 				break;
 		}
 		memcpy(prev_symbol_name, symbol_name, len + 1);
 		prev_symbol_type = symbol_type;
 		prev_start = start;
 	}
 	free(prev_symbol_name);
 	free(line);
 out_close:
 	fclose(file);
 	return err;
 out_failure:
 	return -1;
 }
 struct process_kallsyms_args {
 	struct map *map;
 	struct dso *dso;
 };
 static u8 kallsyms2elf_type(char type)
 {
 	if (type == 'W')
 		return STB_WEAK;
 	return isupper(type) ? STB_GLOBAL : STB_LOCAL;
 }
 static int map__process_kallsym_symbol(void *arg, const char *name,
 				       char type, u64 start, u64 end)
 {
 	struct symbol *sym;
 	struct process_kallsyms_args *a = arg;
 	struct rb_root *root = &a->dso->symbols[a->map->type];
 	if (!symbol_type__is_a(type, a->map->type))
 		return 0;
 	sym = symbol__new(start, end - start + 1,
 			  kallsyms2elf_type(type), name);
 	if (sym == NULL)
 		return -ENOMEM;
 	/*
 	 * We will pass the symbols to the filter later, in
 	 * map__split_kallsyms, when we have split the maps per module
 	 */
 	symbols__insert(root, sym);
 	return 0;
 }
 /*
  * Loads the function entries in /proc/kallsyms into kernel_map->dso,
  * so that we can in the next step set the symbol ->end address and then
  * call kernel_maps__split_kallsyms.
  */
 static int dso__load_all_kallsyms(struct dso *dso, const char *filename,
 				  struct map *map)
 {
 	struct process_kallsyms_args args = { .map = map, .dso = dso, };
 	return kallsyms__parse(filename, &args, map__process_kallsym_symbol);
 }
 /*
  * Split the symbols into maps, making sure there are no overlaps, i.e. the
  * kernel range is broken in several maps, named [kernel].N, as we don't have
  * the original ELF section names vmlinux have.
  */
 static int dso__split_kallsyms(struct dso *dso, struct map *map,
 			       symbol_filter_t filter)
 {
 	struct map_groups *kmaps = map__kmap(map)->kmaps;
 	struct machine *machine = kmaps->machine;
 	struct map *curr_map = map;
 	struct symbol *pos;
 	int count = 0, moved = 0;
 	struct rb_root *root = &dso->symbols[map->type];
 	struct rb_node *next = rb_first(root);
 	int kernel_range = 0;
 	while (next) {
 		char *module;
 		pos = rb_entry(next, struct symbol, rb_node);
 		next = rb_next(&pos->rb_node);
 		module = strchr(pos->name, '\t');
 		if (module) {
 			if (!symbol_conf.use_modules)
 				goto discard_symbol;
 			*module++ = '\0';
 			if (strcmp(curr_map->dso->short_name, module)) {
 				if (curr_map != map &&
 				    dso->kernel == DSO_TYPE_GUEST_KERNEL &&
 				    machine__is_default_guest(machine)) {
 					/*
 					 * We assume all symbols of a module are
 					 * continuous in * kallsyms, so curr_map
 					 * points to a module and all its
 					 * symbols are in its kmap. Mark it as
 					 * loaded.
 					 */
 					dso__set_loaded(curr_map->dso,
 							curr_map->type);
 				}
 				curr_map = map_groups__find_by_name(kmaps,
 							map->type, module);
 				if (curr_map == NULL) {
 					pr_debug("%s/proc/{kallsyms,modules} "
 					         "inconsistency while looking "
 						 "for \"%s\" module!\n",
 						 machine->root_dir, module);
 					curr_map = map;
 					goto discard_symbol;
 				}
 				if (curr_map->dso->loaded &&
 				    !machine__is_default_guest(machine))
 					goto discard_symbol;
 			}
 			/*
 			 * So that we look just like we get from .ko files,
 			 * i.e. not prelinked, relative to map->start.
 			 */
 			pos->start = curr_map->map_ip(curr_map, pos->start);
 			pos->end   = curr_map->map_ip(curr_map, pos->end);
 		} else if (curr_map != map) {
 			char dso_name[PATH_MAX];
 			struct dso *ndso;
 			if (count == 0) {
 				curr_map = map;
 				goto filter_symbol;
 			}
 			if (dso->kernel == DSO_TYPE_GUEST_KERNEL)
 				snprintf(dso_name, sizeof(dso_name),
 					"[guest.kernel].%d",
 					kernel_range++);
 			else
 				snprintf(dso_name, sizeof(dso_name),
 					"[kernel].%d",
 					kernel_range++);
 			ndso = dso__new(dso_name);
 			if (ndso == NULL)
 				return -1;
 			ndso->kernel = dso->kernel;
 			curr_map = map__new2(pos->start, ndso, map->type);
 			if (curr_map == NULL) {
 				dso__delete(ndso);
 				return -1;
 			}
 			curr_map->map_ip = curr_map->unmap_ip = identity__map_ip;
 			map_groups__insert(kmaps, curr_map);
 			++kernel_range;
 		}
 filter_symbol:
 		if (filter && filter(curr_map, pos)) {
 discard_symbol:		rb_erase(&pos->rb_node, root);
 			symbol__delete(pos);
 		} else {
 			if (curr_map != map) {
 				rb_erase(&pos->rb_node, root);
 				symbols__insert(&curr_map->dso->symbols[curr_map->type], pos);
 				++moved;
 			} else
 				++count;
 		}
 	}
 	if (curr_map != map &&
 	    dso->kernel == DSO_TYPE_GUEST_KERNEL &&
 	    machine__is_default_guest(kmaps->machine)) {
 		dso__set_loaded(curr_map->dso, curr_map->type);
 	}
 	return count + moved;
 }
 static bool symbol__restricted_filename(const char *filename,
 					const char *restricted_filename)
 {
 	bool restricted = false;
 	if (symbol_conf.kptr_restrict) {
 		char *r = realpath(filename, NULL);
 		if (r != NULL) {
 			restricted = strcmp(r, restricted_filename) == 0;
 			free(r);
 			return restricted;
 		}
 	}
 	return restricted;
 }
 int dso__load_kallsyms(struct dso *dso, const char *filename,
 		       struct map *map, symbol_filter_t filter)
 {
 	if (symbol__restricted_filename(filename, "/proc/kallsyms"))
 		return -1;
 	if (dso__load_all_kallsyms(dso, filename, map) < 0)
 		return -1;
 	if (dso->kernel == DSO_TYPE_GUEST_KERNEL)
 		dso->symtab_type = SYMTAB__GUEST_KALLSYMS;
 	else
 		dso->symtab_type = SYMTAB__KALLSYMS;
 	return dso__split_kallsyms(dso, map, filter);
 }
 static int dso__load_perf_map(struct dso *dso, struct map *map,
 			      symbol_filter_t filter)
 {
 	char *line = NULL;
 	size_t n;
 	FILE *file;
 	int nr_syms = 0;
 	file = fopen(dso->long_name, "r");
 	if (file == NULL)
 		goto out_failure;
 	while (!feof(file)) {
 		u64 start, size;
 		struct symbol *sym;
 		int line_len, len;
 		line_len = getline(&line, &n, file);
 		if (line_len < 0)
 			break;
 		if (!line)
 			goto out_failure;
 		line[--line_len] = '\0'; /* \n */
 		len = hex2u64(line, &start);
 		len++;
 		if (len + 2 >= line_len)
 			continue;
 		len += hex2u64(line + len, &size);
 		len++;
 		if (len + 2 >= line_len)
 			continue;
 		sym = symbol__new(start, size, STB_GLOBAL, line + len);
 		if (sym == NULL)
 			goto out_delete_line;
 		if (filter && filter(map, sym))
 			symbol__delete(sym);
 		else {
 			symbols__insert(&dso->symbols[map->type], sym);
 			nr_syms++;
 		}
 	}
 	free(line);
 	fclose(file);
 	return nr_syms;
 out_delete_line:
 	free(line);
 out_failure:
 	return -1;
 }
 /**
  * elf_symtab__for_each_symbol - iterate thru all the symbols
  *
  * @syms: struct elf_symtab instance to iterate
  * @idx: uint32_t idx
  * @sym: GElf_Sym iterator
  */
 #define elf_symtab__for_each_symbol(syms, nr_syms, idx, sym) \
 	for (idx = 0, gelf_getsym(syms, idx, &sym);\
 	     idx < nr_syms; \
 	     idx++, gelf_getsym(syms, idx, &sym))
 static inline uint8_t elf_sym__type(const GElf_Sym *sym)
 {
 	return GELF_ST_TYPE(sym->st_info);
 }
 static inline int elf_sym__is_function(const GElf_Sym *sym)
 {
 	return elf_sym__type(sym) == STT_FUNC &&
 	       sym->st_name != 0 &&
 	       sym->st_shndx != SHN_UNDEF;
 }
 static inline bool elf_sym__is_object(const GElf_Sym *sym)
 {
 	return elf_sym__type(sym) == STT_OBJECT &&
 		sym->st_name != 0 &&
 		sym->st_shndx != SHN_UNDEF;
 }
 static inline int elf_sym__is_label(const GElf_Sym *sym)
 {
 	return elf_sym__type(sym) == STT_NOTYPE &&
 		sym->st_name != 0 &&
 		sym->st_shndx != SHN_UNDEF &&
 		sym->st_shndx != SHN_ABS;
 }
 static inline const char *elf_sec__name(const GElf_Shdr *shdr,
 					const Elf_Data *secstrs)
 {
 	return secstrs->d_buf + shdr->sh_name;
 }
 static inline int elf_sec__is_text(const GElf_Shdr *shdr,
 					const Elf_Data *secstrs)
 {
 	return strstr(elf_sec__name(shdr, secstrs), "text") != NULL;
 }
 static inline bool elf_sec__is_data(const GElf_Shdr *shdr,
 				    const Elf_Data *secstrs)
 {
 	return strstr(elf_sec__name(shdr, secstrs), "data") != NULL;
 }
 static inline const char *elf_sym__name(const GElf_Sym *sym,
 					const Elf_Data *symstrs)
 {
 	return symstrs->d_buf + sym->st_name;
 }
 static Elf_Scn *elf_section_by_name(Elf *elf, GElf_Ehdr *ep,
 				    GElf_Shdr *shp, const char *name,
 				    size_t *idx)
 {
 	Elf_Scn *sec = NULL;
 	size_t cnt = 1;
 	while ((sec = elf_nextscn(elf, sec)) != NULL) {
 		char *str;
 		gelf_getshdr(sec, shp);
 		str = elf_strptr(elf, ep->e_shstrndx, shp->sh_name);
 		if (!strcmp(name, str)) {
 			if (idx)
 				*idx = cnt;
 			break;
 		}
 		++cnt;
 	}
 	return sec;
 }
 #define elf_section__for_each_rel(reldata, pos, pos_mem, idx, nr_entries) \
 	for (idx = 0, pos = gelf_getrel(reldata, 0, &pos_mem); \
 	     idx < nr_entries; \
 	     ++idx, pos = gelf_getrel(reldata, idx, &pos_mem))
 #define elf_section__for_each_rela(reldata, pos, pos_mem, idx, nr_entries) \
 	for (idx = 0, pos = gelf_getrela(reldata, 0, &pos_mem); \
 	     idx < nr_entries; \
 	     ++idx, pos = gelf_getrela(reldata, idx, &pos_mem))
 /*
  * We need to check if we have a .dynsym, so that we can handle the
  * .plt, synthesizing its symbols, that aren't on the symtabs (be it
  * .dynsym or .symtab).
  * And always look at the original dso, not at debuginfo packages, that
  * have the PLT data stripped out (shdr_rel_plt.sh_type == SHT_NOBITS).
  */
 static int dso__synthesize_plt_symbols(struct  dso *dso, struct map *map,
 				       symbol_filter_t filter)
 {
 	uint32_t nr_rel_entries, idx;
 	GElf_Sym sym;
 	u64 plt_offset;
 	GElf_Shdr shdr_plt;
 	struct symbol *f;
 	GElf_Shdr shdr_rel_plt, shdr_dynsym;
 	Elf_Data *reldata, *syms, *symstrs;
 	Elf_Scn *scn_plt_rel, *scn_symstrs, *scn_dynsym;
 	size_t dynsym_idx;
 	GElf_Ehdr ehdr;
 	char sympltname[1024];
 	Elf *elf;
 	int nr = 0, symidx, fd, err = 0;
 	char name[PATH_MAX];
 	snprintf(name, sizeof(name), "%s%s",
 		 symbol_conf.symfs, dso->long_name);
 	fd = open(name, O_RDONLY);
 	if (fd < 0)
 		goto out;
 	elf = elf_begin(fd, PERF_ELF_C_READ_MMAP, NULL);
 	if (elf == NULL)
 		goto out_close;
 	if (gelf_getehdr(elf, &ehdr) == NULL)
 		goto out_elf_end;
 	scn_dynsym = elf_section_by_name(elf, &ehdr, &shdr_dynsym,
 					 ".dynsym", &dynsym_idx);
 	if (scn_dynsym == NULL)
 		goto out_elf_end;
 	scn_plt_rel = elf_section_by_name(elf, &ehdr, &shdr_rel_plt,
 					  ".rela.plt", NULL);
 	if (scn_plt_rel == NULL) {
 		scn_plt_rel = elf_section_by_name(elf, &ehdr, &shdr_rel_plt,
 						  ".rel.plt", NULL);
 		if (scn_plt_rel == NULL)
 			goto out_elf_end;
 	}
 	err = -1;
 	if (shdr_rel_plt.sh_link != dynsym_idx)
 		goto out_elf_end;
 	if (elf_section_by_name(elf, &ehdr, &shdr_plt, ".plt", NULL) == NULL)
 		goto out_elf_end;
 	/*
 	 * Fetch the relocation section to find the idxes to the GOT
 	 * and the symbols in the .dynsym they refer to.
 	 */
 	reldata = elf_getdata(scn_plt_rel, NULL);
 	if (reldata == NULL)
 		goto out_elf_end;
 	syms = elf_getdata(scn_dynsym, NULL);
 	if (syms == NULL)
 		goto out_elf_end;
 	scn_symstrs = elf_getscn(elf, shdr_dynsym.sh_link);
 	if (scn_symstrs == NULL)
 		goto out_elf_end;
 	symstrs = elf_getdata(scn_symstrs, NULL);
 	if (symstrs == NULL)
 		goto out_elf_end;
 	nr_rel_entries = shdr_rel_plt.sh_size / shdr_rel_plt.sh_entsize;
 	plt_offset = shdr_plt.sh_offset;
 	if (shdr_rel_plt.sh_type == SHT_RELA) {
 		GElf_Rela pos_mem, *pos;
 		elf_section__for_each_rela(reldata, pos, pos_mem, idx,
 					   nr_rel_entries) {
 			symidx = GELF_R_SYM(pos->r_info);
 			plt_offset += shdr_plt.sh_entsize;
 			gelf_getsym(syms, symidx, &sym);
 			snprintf(sympltname, sizeof(sympltname),
 				 "%s@plt", elf_sym__name(&sym, symstrs));
 			f = symbol__new(plt_offset, shdr_plt.sh_entsize,
 					STB_GLOBAL, sympltname);
 			if (!f)
 				goto out_elf_end;
 			if (filter && filter(map, f))
 				symbol__delete(f);
 			else {
 				symbols__insert(&dso->symbols[map->type], f);
 				++nr;
 			}
 		}
 	} else if (shdr_rel_plt.sh_type == SHT_REL) {
 		GElf_Rel pos_mem, *pos;
 		elf_section__for_each_rel(reldata, pos, pos_mem, idx,
 					  nr_rel_entries) {
 			symidx = GELF_R_SYM(pos->r_info);
 			plt_offset += shdr_plt.sh_entsize;
 			gelf_getsym(syms, symidx, &sym);
 			snprintf(sympltname, sizeof(sympltname),
 				 "%s@plt", elf_sym__name(&sym, symstrs));
 			f = symbol__new(plt_offset, shdr_plt.sh_entsize,
 					STB_GLOBAL, sympltname);
 			if (!f)
 				goto out_elf_end;
 			if (filter && filter(map, f))
 				symbol__delete(f);
 			else {
 				symbols__insert(&dso->symbols[map->type], f);
 				++nr;
 			}
 		}
 	}
 	err = 0;
 out_elf_end:
 	elf_end(elf);
 out_close:
 	close(fd);
 	if (err == 0)
 		return nr;
 out:
 	pr_debug("%s: problems reading %s PLT info.\n",
 		 __func__, dso->long_name);
 	return 0;
 }
 static bool elf_sym__is_a(GElf_Sym *sym, enum map_type type)
 {
 	switch (type) {
 	case MAP__FUNCTION:
 		return elf_sym__is_function(sym);
 	case MAP__VARIABLE:
 		return elf_sym__is_object(sym);
 	default:
 		return false;
 	}
 }
 static bool elf_sec__is_a(GElf_Shdr *shdr, Elf_Data *secstrs,
 			  enum map_type type)
 {
 	switch (type) {
 	case MAP__FUNCTION:
 		return elf_sec__is_text(shdr, secstrs);
 	case MAP__VARIABLE:
 		return elf_sec__is_data(shdr, secstrs);
 	default:
 		return false;
 	}
 }
 static size_t elf_addr_to_index(Elf *elf, GElf_Addr addr)
 {
 	Elf_Scn *sec = NULL;
 	GElf_Shdr shdr;
 	size_t cnt = 1;
 	while ((sec = elf_nextscn(elf, sec)) != NULL) {
 		gelf_getshdr(sec, &shdr);
 		if ((addr >= shdr.sh_addr) &&
 		    (addr < (shdr.sh_addr + shdr.sh_size)))
 			return cnt;
 		++cnt;
 	}
 	return -1;
 }
 static int dso__load_sym(struct dso *dso, struct map *map, const char *name,
 			 int fd, symbol_filter_t filter, int kmodule,
 			 int want_symtab)
 {
 	struct kmap *kmap = dso->kernel ? map__kmap(map) : NULL;
 	struct map *curr_map = map;
 	struct dso *curr_dso = dso;
 	Elf_Data *symstrs, *secstrs;
 	uint32_t nr_syms;
 	int err = -1;
 	uint32_t idx;
 	GElf_Ehdr ehdr;
 	GElf_Shdr shdr, opdshdr;
 	Elf_Data *syms, *opddata = NULL;
 	GElf_Sym sym;
 	Elf_Scn *sec, *sec_strndx, *opdsec;
 	Elf *elf;
 	int nr = 0;
 	size_t opdidx = 0;
 	elf = elf_begin(fd, PERF_ELF_C_READ_MMAP, NULL);
 	if (elf == NULL) {
 		pr_debug("%s: cannot read %s ELF file.\n", __func__, name);
 		goto out_close;
 	}
 	if (gelf_getehdr(elf, &ehdr) == NULL) {
 		pr_debug("%s: cannot get elf header.\n", __func__);
 		goto out_elf_end;
 	}
 	/* Always reject images with a mismatched build-id: */
 	if (dso->has_build_id) {
 		u8 build_id[BUILD_ID_SIZE];
 		if (elf_read_build_id(elf, build_id,
 				      BUILD_ID_SIZE) != BUILD_ID_SIZE)
 			goto out_elf_end;
 		if (!dso__build_id_equal(dso, build_id))
 			goto out_elf_end;
 	}
 	sec = elf_section_by_name(elf, &ehdr, &shdr, ".symtab", NULL);
 	if (sec == NULL) {
 		if (want_symtab)
 			goto out_elf_end;
 		sec = elf_section_by_name(elf, &ehdr, &shdr, ".dynsym", NULL);
 		if (sec == NULL)
 			goto out_elf_end;
 	}
 	opdsec = elf_section_by_name(elf, &ehdr, &opdshdr, ".opd", &opdidx);
 	if (opdsec)
 		opddata = elf_rawdata(opdsec, NULL);
 	syms = elf_getdata(sec, NULL);
 	if (syms == NULL)
 		goto out_elf_end;
 	sec = elf_getscn(elf, shdr.sh_link);
 	if (sec == NULL)
 		goto out_elf_end;
 	symstrs = elf_getdata(sec, NULL);
 	if (symstrs == NULL)
 		goto out_elf_end;
 	sec_strndx = elf_getscn(elf, ehdr.e_shstrndx);
 	if (sec_strndx == NULL)
 		goto out_elf_end;
 	secstrs = elf_getdata(sec_strndx, NULL);
 	if (secstrs == NULL)
 		goto out_elf_end;
 	nr_syms = shdr.sh_size / shdr.sh_entsize;
 	memset(&sym, 0, sizeof(sym));
 	if (dso->kernel == DSO_TYPE_USER) {
 		dso->adjust_symbols = (ehdr.e_type == ET_EXEC ||
 				elf_section_by_name(elf, &ehdr, &shdr,
 						     ".gnu.prelink_undo",
 						     NULL) != NULL);
 	} else {
 		dso->adjust_symbols = 0;
 	}
 	elf_symtab__for_each_symbol(syms, nr_syms, idx, sym) {
 		struct symbol *f;
 		const char *elf_name = elf_sym__name(&sym, symstrs);
 		char *demangled = NULL;
 		int is_label = elf_sym__is_label(&sym);
 		const char *section_name;
 		if (kmap && kmap->ref_reloc_sym && kmap->ref_reloc_sym->name &&
 		    strcmp(elf_name, kmap->ref_reloc_sym->name) == 0)
 			kmap->ref_reloc_sym->unrelocated_addr = sym.st_value;
 		if (!is_label && !elf_sym__is_a(&sym, map->type))
 			continue;
 		/* Reject ARM ELF "mapping symbols": these aren't unique and
 		 * don't identify functions, so will confuse the profile
 		 * output: */
 		if (ehdr.e_machine == EM_ARM) {
 			if (!strcmp(elf_name, "$a") ||
 			    !strcmp(elf_name, "$d") ||
 			    !strcmp(elf_name, "$t"))
 				continue;
 		}
 		if (opdsec && sym.st_shndx == opdidx) {
 			u32 offset = sym.st_value - opdshdr.sh_addr;
 			u64 *opd = opddata->d_buf + offset;
 			sym.st_value = *opd;
 			sym.st_shndx = elf_addr_to_index(elf, sym.st_value);
 		}
 		sec = elf_getscn(elf, sym.st_shndx);
 		if (!sec)
 			goto out_elf_end;
 		gelf_getshdr(sec, &shdr);
 		if (is_label && !elf_sec__is_a(&shdr, secstrs, map->type))
 			continue;
 		section_name = elf_sec__name(&shdr, secstrs);
 		/* On ARM, symbols for thumb functions have 1 added to
 		 * the symbol address as a flag - remove it */
 		if ((ehdr.e_machine == EM_ARM) &&
 		    (map->type == MAP__FUNCTION) &&
 		    (sym.st_value & 1))
 			--sym.st_value;
 		if (dso->kernel != DSO_TYPE_USER || kmodule) {
 			char dso_name[PATH_MAX];
 			if (strcmp(section_name,
 				   (curr_dso->short_name +
 				    dso->short_name_len)) == 0)
 				goto new_symbol;
 			if (strcmp(section_name, ".text") == 0) {
 				curr_map = map;
 				curr_dso = dso;
 				goto new_symbol;
 			}
 			snprintf(dso_name, sizeof(dso_name),
 				 "%s%s", dso->short_name, section_name);
 			curr_map = map_groups__find_by_name(kmap->kmaps, map->type, dso_name);
 			if (curr_map == NULL) {
 				u64 start = sym.st_value;
 				if (kmodule)
 					start += map->start + shdr.sh_offset;
 				curr_dso = dso__new(dso_name);
 				if (curr_dso == NULL)
 					goto out_elf_end;
 				curr_dso->kernel = dso->kernel;
 				curr_dso->long_name = dso->long_name;
 				curr_dso->long_name_len = dso->long_name_len;
 				curr_map = map__new2(start, curr_dso,
 						     map->type);
 				if (curr_map == NULL) {
 					dso__delete(curr_dso);
 					goto out_elf_end;
 				}
 				curr_map->map_ip = identity__map_ip;
 				curr_map->unmap_ip = identity__map_ip;
 				curr_dso->symtab_type = dso->symtab_type;
 				map_groups__insert(kmap->kmaps, curr_map);
 				dsos__add(&dso->node, curr_dso);
 				dso__set_loaded(curr_dso, map->type);
 			} else
 				curr_dso = curr_map->dso;
 			goto new_symbol;
 		}
 		if (curr_dso->adjust_symbols) {
 			pr_debug4("%s: adjusting symbol: st_value: %#" PRIx64 " "
 				  "sh_addr: %#" PRIx64 " sh_offset: %#" PRIx64 "\n", __func__,
 				  (u64)sym.st_value, (u64)shdr.sh_addr,
 				  (u64)shdr.sh_offset);
 			sym.st_value -= shdr.sh_addr - shdr.sh_offset;
 		}
 		/*
 		 * We need to figure out if the object was created from C++ sources
 		 * DWARF DW_compile_unit has this, but we don't always have access
 		 * to it...
 		 */
 		demangled = bfd_demangle(NULL, elf_name, DMGL_PARAMS | DMGL_ANSI);
 		if (demangled != NULL)
 			elf_name = demangled;
 new_symbol:
 		f = symbol__new(sym.st_value, sym.st_size,
 				GELF_ST_BIND(sym.st_info), elf_name);
 		free(demangled);
 		if (!f)
 			goto out_elf_end;
 		if (filter && filter(curr_map, f))
 			symbol__delete(f);
 		else {
 			symbols__insert(&curr_dso->symbols[curr_map->type], f);
 			nr++;
 		}
 	}
 	/*
 	 * For misannotated, zeroed, ASM function sizes.
 	 */
 	if (nr > 0) {
 		symbols__fixup_end(&dso->symbols[map->type]);
 		if (kmap) {
 			/*
 			 * We need to fixup this here too because we create new
 			 * maps here, for things like vsyscall sections.
 			 */
 			__map_groups__fixup_end(kmap->kmaps, map->type);
 		}
 	}
 	err = nr;
 out_elf_end:
 	elf_end(elf);
 out_close:
 	return err;
 }
 static bool dso__build_id_equal(const struct dso *dso, u8 *build_id)
 {
 	return memcmp(dso->build_id, build_id, sizeof(dso->build_id)) == 0;
 }
 bool __dsos__read_build_ids(struct list_head *head, bool with_hits)
 {
 	bool have_build_id = false;
 	struct dso *pos;
 	list_for_each_entry(pos, head, node) {
 		if (with_hits && !pos->hit)
 			continue;
 		if (pos->has_build_id) {
 			have_build_id = true;
 			continue;
 		}
 		if (filename__read_build_id(pos->long_name, pos->build_id,
 					    sizeof(pos->build_id)) > 0) {
 			have_build_id	  = true;
 			pos->has_build_id = true;
 		}
 	}
 	return have_build_id;
 }
 /*
  * Align offset to 4 bytes as needed for note name and descriptor data.
  */
 #define NOTE_ALIGN(n) (((n) + 3) & -4U)
 static int elf_read_build_id(Elf *elf, void *bf, size_t size)
 {
 	int err = -1;
 	GElf_Ehdr ehdr;
 	GElf_Shdr shdr;
 	Elf_Data *data;
 	Elf_Scn *sec;
 	Elf_Kind ek;
 	void *ptr;
 	if (size < BUILD_ID_SIZE)
 		goto out;
 	ek = elf_kind(elf);
 	if (ek != ELF_K_ELF)
 		goto out;
 	if (gelf_getehdr(elf, &ehdr) == NULL) {
 		pr_err("%s: cannot get elf header.\n", __func__);
 		goto out;
 	}
 	sec = elf_section_by_name(elf, &ehdr, &shdr,
 				  ".note.gnu.build-id", NULL);
 	if (sec == NULL) {
 		sec = elf_section_by_name(elf, &ehdr, &shdr,
 					  ".notes", NULL);
 		if (sec == NULL)
 			goto out;
 	}
 	data = elf_getdata(sec, NULL);
 	if (data == NULL)
 		goto out;
 	ptr = data->d_buf;
 	while (ptr < (data->d_buf + data->d_size)) {
 		GElf_Nhdr *nhdr = ptr;
 		int namesz = NOTE_ALIGN(nhdr->n_namesz),
 		    descsz = NOTE_ALIGN(nhdr->n_descsz);
 		const char *name;
 		ptr += sizeof(*nhdr);
 		name = ptr;
 		ptr += namesz;
 		if (nhdr->n_type == NT_GNU_BUILD_ID &&
 		    nhdr->n_namesz == sizeof("GNU")) {
 			if (memcmp(name, "GNU", sizeof("GNU")) == 0) {
 				memcpy(bf, ptr, BUILD_ID_SIZE);
 				err = BUILD_ID_SIZE;
 				break;
 			}
 		}
 		ptr += descsz;
 	}
 out:
 	return err;
 }
 int filename__read_build_id(const char *filename, void *bf, size_t size)
 {
 	int fd, err = -1;
 	Elf *elf;
 	if (size < BUILD_ID_SIZE)
 		goto out;
 	fd = open(filename, O_RDONLY);
 	if (fd < 0)
 		goto out;
 	elf = elf_begin(fd, PERF_ELF_C_READ_MMAP, NULL);
 	if (elf == NULL) {
 		pr_debug2("%s: cannot read %s ELF file.\n", __func__, filename);
 		goto out_close;
 	}
 	err = elf_read_build_id(elf, bf, size);
 	elf_end(elf);
 out_close:
 	close(fd);
 out:
 	return err;
 }
 int sysfs__read_build_id(const char *filename, void *build_id, size_t size)
 {
 	int fd, err = -1;
 	if (size < BUILD_ID_SIZE)
 		goto out;
 	fd = open(filename, O_RDONLY);
 	if (fd < 0)
 		goto out;
 	while (1) {
 		char bf[BUFSIZ];
 		GElf_Nhdr nhdr;
 		int namesz, descsz;
 		if (read(fd, &nhdr, sizeof(nhdr)) != sizeof(nhdr))
 			break;
 		namesz = NOTE_ALIGN(nhdr.n_namesz);
 		descsz = NOTE_ALIGN(nhdr.n_descsz);
 		if (nhdr.n_type == NT_GNU_BUILD_ID &&
 		    nhdr.n_namesz == sizeof("GNU")) {
 			if (read(fd, bf, namesz) != namesz)
 				break;
 			if (memcmp(bf, "GNU", sizeof("GNU")) == 0) {
 				if (read(fd, build_id,
 				    BUILD_ID_SIZE) == BUILD_ID_SIZE) {
 					err = 0;
 					break;
 				}
 			} else if (read(fd, bf, descsz) != descsz)
 				break;
 		} else {
 			int n = namesz + descsz;
 			if (read(fd, bf, n) != n)
 				break;
 		}
 	}
 	close(fd);
 out:
 	return err;
 }
 char dso__symtab_origin(const struct dso *dso)
 {
 	static const char origin[] = {
 		[SYMTAB__KALLSYMS]	      = 'k',
 		[SYMTAB__JAVA_JIT]	      = 'j',
 		[SYMTAB__BUILD_ID_CACHE]      = 'B',
 		[SYMTAB__FEDORA_DEBUGINFO]    = 'f',
 		[SYMTAB__UBUNTU_DEBUGINFO]    = 'u',
 		[SYMTAB__BUILDID_DEBUGINFO]   = 'b',
 		[SYMTAB__SYSTEM_PATH_DSO]     = 'd',
 		[SYMTAB__SYSTEM_PATH_KMODULE] = 'K',
 		[SYMTAB__GUEST_KALLSYMS]      =  'g',
 		[SYMTAB__GUEST_KMODULE]	      =  'G',
 	};
 	if (dso == NULL || dso->symtab_type == SYMTAB__NOT_FOUND)
 		return '!';
 	return origin[dso->symtab_type];
 }
 int dso__load(struct dso *dso, struct map *map, symbol_filter_t filter)
 {
 	int size = PATH_MAX;
 	char *name;
 	int ret = -1;
 	int fd;
 	struct machine *machine;
 	const char *root_dir;
 	int want_symtab;
 	dso__set_loaded(dso, map->type);
 	if (dso->kernel == DSO_TYPE_KERNEL)
 		return dso__load_kernel_sym(dso, map, filter);
 	else if (dso->kernel == DSO_TYPE_GUEST_KERNEL)
 		return dso__load_guest_kernel_sym(dso, map, filter);
 	if (map->groups && map->groups->machine)
 		machine = map->groups->machine;
 	else
 		machine = NULL;
 	name = malloc(size);
 	if (!name)
 		return -1;
 	dso->adjust_symbols = 0;
 	if (strncmp(dso->name, "/tmp/perf-", 10) == 0) {
+		struct stat st;
+		if (stat(dso->name, &st) < 0)
+			return -1;
+		if (st.st_uid && (st.st_uid != geteuid())) {
+			pr_warning("File %s not owned by current user or root, "
+				"ignoring it.\n", dso->name);
+			return -1;
+		}
 		ret = dso__load_perf_map(dso, map, filter);
 		dso->symtab_type = ret > 0 ? SYMTAB__JAVA_JIT :
 					      SYMTAB__NOT_FOUND;
 		return ret;
 	}
 	/* Iterate over candidate debug images.
 	 * On the first pass, only load images if they have a full symtab.
 	 * Failing that, do a second pass where we accept .dynsym also
 	 */
 	want_symtab = 1;
 restart:
 	for (dso->symtab_type = SYMTAB__BUILD_ID_CACHE;
 	     dso->symtab_type != SYMTAB__NOT_FOUND;
 	     dso->symtab_type++) {
 		switch (dso->symtab_type) {
 		case SYMTAB__BUILD_ID_CACHE:
 			/* skip the locally configured cache if a symfs is given */
 			if (symbol_conf.symfs[0] ||
 			    (dso__build_id_filename(dso, name, size) == NULL)) {
 				continue;
 			}
 			break;
 		case SYMTAB__FEDORA_DEBUGINFO:
 			snprintf(name, size, "%s/usr/lib/debug%s.debug",
 				 symbol_conf.symfs, dso->long_name);
 			break;
 		case SYMTAB__UBUNTU_DEBUGINFO:
 			snprintf(name, size, "%s/usr/lib/debug%s",
 				 symbol_conf.symfs, dso->long_name);
 			break;
 		case SYMTAB__BUILDID_DEBUGINFO: {
 			char build_id_hex[BUILD_ID_SIZE * 2 + 1];
 			if (!dso->has_build_id)
 				continue;
 			build_id__sprintf(dso->build_id,
 					  sizeof(dso->build_id),
 					  build_id_hex);
 			snprintf(name, size,
 				 "%s/usr/lib/debug/.build-id/%.2s/%s.debug",
 				 symbol_conf.symfs, build_id_hex, build_id_hex + 2);
 			}
 			break;
 		case SYMTAB__SYSTEM_PATH_DSO:
 			snprintf(name, size, "%s%s",
 			     symbol_conf.symfs, dso->long_name);
 			break;
 		case SYMTAB__GUEST_KMODULE:
 			if (map->groups && machine)
 				root_dir = machine->root_dir;
 			else
 				root_dir = "";
 			snprintf(name, size, "%s%s%s", symbol_conf.symfs,
 				 root_dir, dso->long_name);
 			break;
 		case SYMTAB__SYSTEM_PATH_KMODULE:
 			snprintf(name, size, "%s%s", symbol_conf.symfs,
 				 dso->long_name);
 			break;
 		default:;
 		}
 		/* Name is now the name of the next image to try */
 		fd = open(name, O_RDONLY);
 		if (fd < 0)
 			continue;
 		ret = dso__load_sym(dso, map, name, fd, filter, 0,
 				    want_symtab);
 		close(fd);
 		/*
 		 * Some people seem to have debuginfo files _WITHOUT_ debug
 		 * info!?!?
 		 */
 		if (!ret)
 			continue;
 		if (ret > 0) {
 			int nr_plt = dso__synthesize_plt_symbols(dso, map,
 								 filter);
 			if (nr_plt > 0)
 				ret += nr_plt;
 			break;
 		}
 	}
 	/*
 	 * If we wanted a full symtab but no image had one,
 	 * relax our requirements and repeat the search.
 	 */
 	if (ret <= 0 && want_symtab) {
 		want_symtab = 0;
 		goto restart;
 	}
 	free(name);
 	if (ret < 0 && strstr(dso->name, " (deleted)") != NULL)
 		return 0;
 	return ret;
 }
 struct map *map_groups__find_by_name(struct map_groups *mg,
 				     enum map_type type, const char *name)
 {
 	struct rb_node *nd;
 	for (nd = rb_first(&mg->maps[type]); nd; nd = rb_next(nd)) {
 		struct map *map = rb_entry(nd, struct map, rb_node);
 		if (map->dso && strcmp(map->dso->short_name, name) == 0)
 			return map;
 	}
 	return NULL;
 }
 static int dso__kernel_module_get_build_id(struct dso *dso,
 					   const char *root_dir)
 {
 	char filename[PATH_MAX];
 	/*
 	 * kernel module short names are of the form "[module]" and
 	 * we need just "module" here.
 	 */
 	const char *name = dso->short_name + 1;
 	snprintf(filename, sizeof(filename),
 		 "%s/sys/module/%.*s/notes/.note.gnu.build-id",
 		 root_dir, (int)strlen(name) - 1, name);
 	if (sysfs__read_build_id(filename, dso->build_id,
 				 sizeof(dso->build_id)) == 0)
 		dso->has_build_id = true;
 	return 0;
 }
 static int map_groups__set_modules_path_dir(struct map_groups *mg,
 				const char *dir_name)
 {
 	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*/
 		sprintf(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;
 			snprintf(path, sizeof(path), "%s/%s",
 				 dir_name, dent->d_name);
 			ret = map_groups__set_modules_path_dir(mg, path);
 			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 || strcmp(dot, ".ko"))
 				continue;
 			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;
 			snprintf(path, sizeof(path), "%s/%s",
 				 dir_name, dent->d_name);
 			long_name = strdup(path);
 			if (long_name == NULL) {
 				ret = -1;
 				goto out;
 			}
 			dso__set_long_name(map->dso, long_name);
 			map->dso->lname_alloc = 1;
 			dso__kernel_module_get_build_id(map->dso, "");
 		}
 	}
 out:
 	closedir(dir);
 	return ret;
 }
 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 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/kernel",
 		 machine->root_dir, version);
 	free(version);
 	return map_groups__set_modules_path_dir(&machine->kmaps, modules_path);
 }
 /*
  * Constructor variant for modules (where we know from /proc/modules where
  * they are loaded) and for vmlinux, where only after we load all the
  * symbols we'll know where it starts and ends.
  */
 static struct map *map__new2(u64 start, struct dso *dso, enum map_type type)
 {
 	struct map *map = calloc(1, (sizeof(*map) +
 				     (dso->kernel ? sizeof(struct kmap) : 0)));
 	if (map != NULL) {
 		/*
 		 * ->end will be filled after we load all the symbols
 		 */
 		map__init(map, type, start, 0, 0, dso);
 	}
 	return map;
 }
 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);
 	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 = SYMTAB__SYSTEM_PATH_KMODULE;
 	else
 		dso->symtab_type = SYMTAB__GUEST_KMODULE;
 	map_groups__insert(&machine->kmaps, map);
 	return map;
 }
 static int machine__create_modules(struct machine *machine)
 {
 	char *line = NULL;
 	size_t n;
 	FILE *file;
 	struct map *map;
 	const char *modules;
 	char path[PATH_MAX];
 	if (machine__is_default_guest(machine))
 		modules = symbol_conf.default_guest_modules;
 	else {
 		sprintf(path, "%s/proc/modules", machine->root_dir);
 		modules = path;
 	}
 	if (symbol__restricted_filename(path, "/proc/modules"))
 		return -1;
 	file = fopen(modules, "r");
 	if (file == NULL)
 		return -1;
 	while (!feof(file)) {
 		char name[PATH_MAX];
 		u64 start;
 		char *sep;
 		int line_len;
 		line_len = getline(&line, &n, file);
 		if (line_len < 0)
 			break;
 		if (!line)
 			goto out_failure;
 		line[--line_len] = '\0'; /* \n */
 		sep = strrchr(line, 'x');
 		if (sep == NULL)
 			continue;
 		hex2u64(sep + 1, &start);
 		sep = strchr(line, ' ');
 		if (sep == NULL)
 			continue;
 		*sep = '\0';
 		snprintf(name, sizeof(name), "[%s]", line);
 		map = machine__new_module(machine, start, name);
 		if (map == NULL)
 			goto out_delete_line;
 		dso__kernel_module_get_build_id(map->dso, machine->root_dir);
 	}
 	free(line);
 	fclose(file);
 	return machine__set_modules_path(machine);
 out_delete_line:
 	free(line);
 out_failure:
 	return -1;
 }
 int dso__load_vmlinux(struct dso *dso, struct map *map,
 		      const char *vmlinux, symbol_filter_t filter)
 {
 	int err = -1, fd;
 	char symfs_vmlinux[PATH_MAX];
 	snprintf(symfs_vmlinux, sizeof(symfs_vmlinux), "%s%s",
 		 symbol_conf.symfs, vmlinux);
 	fd = open(symfs_vmlinux, O_RDONLY);
 	if (fd < 0)
 		return -1;
 	dso__set_long_name(dso, (char *)vmlinux);
 	dso__set_loaded(dso, map->type);
 	err = dso__load_sym(dso, map, symfs_vmlinux, fd, filter, 0, 0);
 	close(fd);
 	if (err > 0)
 		pr_debug("Using %s for symbols\n", symfs_vmlinux);
 	return err;
 }
 int dso__load_vmlinux_path(struct dso *dso, struct map *map,
 			   symbol_filter_t filter)
 {
 	int i, err = 0;
 	char *filename;
 	pr_debug("Looking at the vmlinux_path (%d entries long)\n",
 		 vmlinux_path__nr_entries + 1);
 	filename = dso__build_id_filename(dso, NULL, 0);
 	if (filename != NULL) {
 		err = dso__load_vmlinux(dso, map, filename, filter);
 		if (err > 0) {
 			dso__set_long_name(dso, filename);
 			goto out;
 		}
 		free(filename);
 	}
 	for (i = 0; i < vmlinux_path__nr_entries; ++i) {
 		err = dso__load_vmlinux(dso, map, vmlinux_path[i], filter);
 		if (err > 0) {
 			dso__set_long_name(dso, strdup(vmlinux_path[i]));
 			break;
 		}
 	}
 out:
 	return err;
 }
 static int dso__load_kernel_sym(struct dso *dso, struct map *map,
 				symbol_filter_t filter)
 {
 	int err;
 	const char *kallsyms_filename = NULL;
 	char *kallsyms_allocated_filename = NULL;
 	/*
 	 * Step 1: if the user specified a kallsyms or vmlinux filename, use
 	 * it and only it, reporting errors to the user if it cannot be used.
 	 *
 	 * For instance, try to analyse an ARM perf.data file _without_ a
 	 * build-id, or if the user specifies the wrong path to the right
 	 * vmlinux file, obviously we can't fallback to another vmlinux (a
 	 * x86_86 one, on the machine where analysis is being performed, say),
 	 * or worse, /proc/kallsyms.
 	 *
 	 * If the specified file _has_ a build-id and there is a build-id
 	 * section in the perf.data file, we will still do the expected
 	 * validation in dso__load_vmlinux and will bail out if they don't
 	 * match.
 	 */
 	if (symbol_conf.kallsyms_name != NULL) {
 		kallsyms_filename = symbol_conf.kallsyms_name;
 		goto do_kallsyms;
 	}
 	if (symbol_conf.vmlinux_name != NULL) {
 		err = dso__load_vmlinux(dso, map,
 					symbol_conf.vmlinux_name, filter);
 		if (err > 0) {
 			dso__set_long_name(dso,
 					   strdup(symbol_conf.vmlinux_name));
 			goto out_fixup;
 		}
 		return err;
 	}
 	if (vmlinux_path != NULL) {
 		err = dso__load_vmlinux_path(dso, map, filter);
 		if (err > 0)
 			goto out_fixup;
 	}
 	/* do not try local files if a symfs was given */
 	if (symbol_conf.symfs[0] != 0)
 		return -1;
 	/*
 	 * Say the kernel DSO was created when processing the build-id header table,
 	 * we have a build-id, so check if it is the same as the running kernel,
 	 * using it if it is.
 	 */
 	if (dso->has_build_id) {
 		u8 kallsyms_build_id[BUILD_ID_SIZE];
 		char sbuild_id[BUILD_ID_SIZE * 2 + 1];
 		if (sysfs__read_build_id("/sys/kernel/notes", kallsyms_build_id,
 					 sizeof(kallsyms_build_id)) == 0) {
 			if (dso__build_id_equal(dso, kallsyms_build_id)) {
 				kallsyms_filename = "/proc/kallsyms";
 				goto do_kallsyms;
 			}
 		}
 		/*
 		 * Now look if we have it on the build-id cache in
 		 * $HOME/.debug/[kernel.kallsyms].
 		 */
 		build_id__sprintf(dso->build_id, sizeof(dso->build_id),
 				  sbuild_id);
 		if (asprintf(&kallsyms_allocated_filename,
 			     "%s/.debug/[kernel.kallsyms]/%s",
 			     getenv("HOME"), sbuild_id) == -1) {
 			pr_err("Not enough memory for kallsyms file lookup\n");
 			return -1;
 		}
 		kallsyms_filename = kallsyms_allocated_filename;
 		if (access(kallsyms_filename, F_OK)) {
 			pr_err("No kallsyms or vmlinux with build-id %s "
 			       "was found\n", sbuild_id);
 			free(kallsyms_allocated_filename);
 			return -1;
 		}
 	} else {
 		/*
 		 * Last resort, if we don't have a build-id and couldn't find
 		 * any vmlinux file, try the running kernel kallsyms table.
 		 */
 		kallsyms_filename = "/proc/kallsyms";
 	}
 do_kallsyms:
 	err = dso__load_kallsyms(dso, kallsyms_filename, map, filter);
 	if (err > 0)
 		pr_debug("Using %s for symbols\n", kallsyms_filename);
 	free(kallsyms_allocated_filename);
 	if (err > 0) {
 out_fixup:
 		if (kallsyms_filename != NULL)
 			dso__set_long_name(dso, strdup("[kernel.kallsyms]"));
 		map__fixup_start(map);
 		map__fixup_end(map);
 	}
 	return err;
 }
 static int dso__load_guest_kernel_sym(struct dso *dso, struct map *map,
 				      symbol_filter_t filter)
 {
 	int err;
 	const char *kallsyms_filename = NULL;
 	struct machine *machine;
 	char path[PATH_MAX];
 	if (!map->groups) {
 		pr_debug("Guest kernel map hasn't the point to groups\n");
 		return -1;
 	}
 	machine = map->groups->machine;
 	if (machine__is_default_guest(machine)) {
 		/*
 		 * if the user specified a vmlinux filename, use it and only
 		 * it, reporting errors to the user if it cannot be used.
 		 * Or use file guest_kallsyms inputted by user on commandline
 		 */
 		if (symbol_conf.default_guest_vmlinux_name != NULL) {
 			err = dso__load_vmlinux(dso, map,
 				symbol_conf.default_guest_vmlinux_name, filter);
 			goto out_try_fixup;
 		}
 		kallsyms_filename = symbol_conf.default_guest_kallsyms;
 		if (!kallsyms_filename)
 			return -1;
 	} else {
 		sprintf(path, "%s/proc/kallsyms", machine->root_dir);
 		kallsyms_filename = path;
 	}
 	err = dso__load_kallsyms(dso, kallsyms_filename, map, filter);
 	if (err > 0)
 		pr_debug("Using %s for symbols\n", kallsyms_filename);
 out_try_fixup:
 	if (err > 0) {
 		if (kallsyms_filename != NULL) {
 			machine__mmap_name(machine, path, sizeof(path));
 			dso__set_long_name(dso, strdup(path));
 		}
 		map__fixup_start(map);
 		map__fixup_end(map);
 	}
 	return err;
 }
 static void dsos__add(struct list_head *head, struct dso *dso)
 {
 	list_add_tail(&dso->node, head);
 }
 static struct dso *dsos__find(struct list_head *head, const char *name)
 {
 	struct dso *pos;
 	list_for_each_entry(pos, head, node)
 		if (strcmp(pos->long_name, name) == 0)
 			return pos;
 	return NULL;
 }
 struct dso *__dsos__findnew(struct list_head *head, const char *name)
 {
 	struct dso *dso = dsos__find(head, name);
 	if (!dso) {
 		dso = dso__new(name);
 		if (dso != NULL) {
 			dsos__add(head, dso);
 			dso__set_basename(dso);
 		}
 	}
 	return dso;
 }
 size_t __dsos__fprintf(struct list_head *head, FILE *fp)
 {
 	struct dso *pos;
 	size_t ret = 0;
 	list_for_each_entry(pos, head, node) {
 		int i;
 		for (i = 0; i < MAP__NR_TYPES; ++i)
 			ret += dso__fprintf(pos, i, fp);
 	}
 	return ret;
 }
 size_t machines__fprintf_dsos(struct rb_root *machines, FILE *fp)
 {
 	struct rb_node *nd;
 	size_t ret = 0;
 	for (nd = rb_first(machines); nd; nd = rb_next(nd)) {
 		struct machine *pos = rb_entry(nd, struct machine, rb_node);
 		ret += __dsos__fprintf(&pos->kernel_dsos, fp);
 		ret += __dsos__fprintf(&pos->user_dsos, fp);
 	}
 	return ret;
 }
 static size_t __dsos__fprintf_buildid(struct list_head *head, FILE *fp,
 				      bool with_hits)
 {
 	struct dso *pos;
 	size_t ret = 0;
 	list_for_each_entry(pos, head, node) {
 		if (with_hits && !pos->hit)
 			continue;
 		ret += dso__fprintf_buildid(pos, fp);
 		ret += fprintf(fp, " %s\n", pos->long_name);
 	}
 	return ret;
 }
 size_t machine__fprintf_dsos_buildid(struct machine *machine, FILE *fp,
 				     bool with_hits)
 {
 	return __dsos__fprintf_buildid(&machine->kernel_dsos, fp, with_hits) +
 	       __dsos__fprintf_buildid(&machine->user_dsos, fp, with_hits);
 }
 size_t machines__fprintf_dsos_buildid(struct rb_root *machines,
 				      FILE *fp, bool with_hits)
 {
 	struct rb_node *nd;
 	size_t ret = 0;
 	for (nd = rb_first(machines); nd; nd = rb_next(nd)) {
 		struct machine *pos = rb_entry(nd, struct machine, rb_node);
 		ret += machine__fprintf_dsos_buildid(pos, fp, with_hits);
 	}
 	return ret;
 }
 struct dso *dso__new_kernel(const char *name)
 {
 	struct dso *dso = dso__new(name ?: "[kernel.kallsyms]");
 	if (dso != NULL) {
 		dso__set_short_name(dso, "[kernel]");
 		dso->kernel = DSO_TYPE_KERNEL;
 	}
 	return dso;
 }
 static struct dso *dso__new_guest_kernel(struct machine *machine,
 					const char *name)
 {
 	char bf[PATH_MAX];
 	struct dso *dso = dso__new(name ?: machine__mmap_name(machine, bf,
 							      sizeof(bf)));
 	if (dso != NULL) {
 		dso__set_short_name(dso, "[guest.kernel]");
 		dso->kernel = DSO_TYPE_GUEST_KERNEL;
 	}
 	return dso;
 }
 void dso__read_running_kernel_build_id(struct dso *dso, struct machine *machine)
 {
 	char path[PATH_MAX];
 	if (machine__is_default_guest(machine))
 		return;
 	sprintf(path, "%s/sys/kernel/notes", machine->root_dir);
 	if (sysfs__read_build_id(path, dso->build_id,
 				 sizeof(dso->build_id)) == 0)
 		dso->has_build_id = true;
 }
 static struct dso *machine__create_kernel(struct machine *machine)
 {
 	const char *vmlinux_name = NULL;
 	struct dso *kernel;
 	if (machine__is_host(machine)) {
 		vmlinux_name = symbol_conf.vmlinux_name;
 		kernel = dso__new_kernel(vmlinux_name);
 	} else {
 		if (machine__is_default_guest(machine))
 			vmlinux_name = symbol_conf.default_guest_vmlinux_name;
 		kernel = dso__new_guest_kernel(machine, vmlinux_name);
 	}
 	if (kernel != NULL) {
 		dso__read_running_kernel_build_id(kernel, machine);
 		dsos__add(&machine->kernel_dsos, kernel);
 	}
 	return kernel;
 }
 struct process_args {
 	u64 start;
 };
 static int symbol__in_kernel(void *arg, const char *name,
 			     char type __used, u64 start, u64 end __used)
 {
 	struct process_args *args = arg;
 	if (strchr(name, '['))
 		return 0;
 	args->start = start;
 	return 1;
 }
 /* Figure out the start address of kernel map from /proc/kallsyms */
 static u64 machine__get_kernel_start_addr(struct machine *machine)
 {
 	const char *filename;
 	char path[PATH_MAX];
 	struct process_args args;
 	if (machine__is_host(machine)) {
 		filename = "/proc/kallsyms";
 	} else {
 		if (machine__is_default_guest(machine))
 			filename = (char *)symbol_conf.default_guest_kallsyms;
 		else {
 			sprintf(path, "%s/proc/kallsyms", machine->root_dir);
 			filename = path;
 		}
 	}
 	if (symbol__restricted_filename(filename, "/proc/kallsyms"))
 		return 0;
 	if (kallsyms__parse(filename, &args, symbol__in_kernel) <= 0)
 		return 0;
 	return args.start;
 }
 int __machine__create_kernel_maps(struct machine *machine, struct dso *kernel)
 {
 	enum map_type type;
 	u64 start = machine__get_kernel_start_addr(machine);
 	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) {
 				free((char *)kmap->ref_reloc_sym->name);
 				kmap->ref_reloc_sym->name = NULL;
 				free(kmap->ref_reloc_sym);
 			}
 			kmap->ref_reloc_sym = NULL;
 		}
 		map__delete(machine->vmlinux_maps[type]);
 		machine->vmlinux_maps[type] = NULL;
 	}
 }
 int machine__create_kernel_maps(struct machine *machine)
 {
 	struct dso *kernel = machine__create_kernel(machine);
 	if (kernel == NULL ||
 	    __machine__create_kernel_maps(machine, kernel) < 0)
 		return -1;
 	if (symbol_conf.use_modules && machine__create_modules(machine) < 0)
 		pr_debug("Problems creating module maps, continuing anyway...\n");
 	/*
 	 * Now that we have all the maps created, just set the ->end of them:
 	 */
 	map_groups__fixup_end(&machine->kmaps);
 	return 0;
 }
 static void vmlinux_path__exit(void)
 {
 	while (--vmlinux_path__nr_entries >= 0) {
 		free(vmlinux_path[vmlinux_path__nr_entries]);
 		vmlinux_path[vmlinux_path__nr_entries] = NULL;
 	}
 	free(vmlinux_path);
 	vmlinux_path = NULL;
 }
 static int vmlinux_path__init(void)
 {
 	struct utsname uts;
 	char bf[PATH_MAX];
 	vmlinux_path = malloc(sizeof(char *) * 5);
 	if (vmlinux_path == NULL)
 		return -1;
 	vmlinux_path[vmlinux_path__nr_entries] = strdup("vmlinux");
 	if (vmlinux_path[vmlinux_path__nr_entries] == NULL)
 		goto out_fail;
 	++vmlinux_path__nr_entries;
 	vmlinux_path[vmlinux_path__nr_entries] = strdup("/boot/vmlinux");
 	if (vmlinux_path[vmlinux_path__nr_entries] == NULL)
 		goto out_fail;
 	++vmlinux_path__nr_entries;
 	/* only try running kernel version if no symfs was given */
 	if (symbol_conf.symfs[0] != 0)
 		return 0;
 	if (uname(&uts) < 0)
 		return -1;
 	snprintf(bf, sizeof(bf), "/boot/vmlinux-%s", uts.release);
 	vmlinux_path[vmlinux_path__nr_entries] = strdup(bf);
 	if (vmlinux_path[vmlinux_path__nr_entries] == NULL)
 		goto out_fail;
 	++vmlinux_path__nr_entries;
 	snprintf(bf, sizeof(bf), "/lib/modules/%s/build/vmlinux", uts.release);
 	vmlinux_path[vmlinux_path__nr_entries] = strdup(bf);
 	if (vmlinux_path[vmlinux_path__nr_entries] == NULL)
 		goto out_fail;
 	++vmlinux_path__nr_entries;
 	snprintf(bf, sizeof(bf), "/usr/lib/debug/lib/modules/%s/vmlinux",
 		 uts.release);
 	vmlinux_path[vmlinux_path__nr_entries] = strdup(bf);
 	if (vmlinux_path[vmlinux_path__nr_entries] == NULL)
 		goto out_fail;
 	++vmlinux_path__nr_entries;
 	return 0;
 out_fail:
 	vmlinux_path__exit();
 	return -1;
 }
 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;
 }
 static int setup_list(struct strlist **list, const char *list_str,
 		      const char *list_name)
 {
 	if (list_str == NULL)
 		return 0;
 	*list = strlist__new(true, list_str);
 	if (!*list) {
 		pr_err("problems parsing %s list\n", list_name);
 		return -1;
 	}
 	return 0;
 }
 static bool symbol__read_kptr_restrict(void)
 {
 	bool value = false;
 	if (geteuid() != 0) {
 		FILE *fp = fopen("/proc/sys/kernel/kptr_restrict", "r");
 		if (fp != NULL) {
 			char line[8];
 			if (fgets(line, sizeof(line), fp) != NULL)
 				value = atoi(line) != 0;
 			fclose(fp);
 		}
 	}
 	return value;
 }
 int symbol__init(void)
 {
 	const char *symfs;
 	if (symbol_conf.initialized)
 		return 0;
 	symbol_conf.priv_size = ALIGN(symbol_conf.priv_size, sizeof(u64));
 	elf_version(EV_CURRENT);
 	if (symbol_conf.sort_by_name)
 		symbol_conf.priv_size += (sizeof(struct symbol_name_rb_node) -
 					  sizeof(struct symbol));
 	if (symbol_conf.try_vmlinux_path && vmlinux_path__init() < 0)
 		return -1;
 	if (symbol_conf.field_sep && *symbol_conf.field_sep == '.') {
 		pr_err("'.' is the only non valid --field-separator argument\n");
 		return -1;
 	}
 	if (setup_list(&symbol_conf.dso_list,
 		       symbol_conf.dso_list_str, "dso") < 0)
 		return -1;
 	if (setup_list(&symbol_conf.comm_list,
 		       symbol_conf.comm_list_str, "comm") < 0)
 		goto out_free_dso_list;
 	if (setup_list(&symbol_conf.sym_list,
 		       symbol_conf.sym_list_str, "symbol") < 0)
 		goto out_free_comm_list;
 	/*
 	 * A path to symbols of "/" is identical to ""
 	 * reset here for simplicity.
 	 */
 	symfs = realpath(symbol_conf.symfs, NULL);
 	if (symfs == NULL)
 		symfs = symbol_conf.symfs;
 	if (strcmp(symfs, "/") == 0)
 		symbol_conf.symfs = "";
 	if (symfs != symbol_conf.symfs)
 		free((void *)symfs);
 	symbol_conf.kptr_restrict = symbol__read_kptr_restrict();
 	symbol_conf.initialized = true;
 	return 0;
 out_free_dso_list:
 	strlist__delete(symbol_conf.dso_list);
 out_free_comm_list:
 	strlist__delete(symbol_conf.comm_list);
 	return -1;
 }
 void symbol__exit(void)
 {
 	if (!symbol_conf.initialized)
 		return;
 	strlist__delete(symbol_conf.sym_list);
 	strlist__delete(symbol_conf.dso_list);
 	strlist__delete(symbol_conf.comm_list);
 	vmlinux_path__exit();
 	symbol_conf.sym_list = symbol_conf.dso_list = symbol_conf.comm_list = NULL;
 	symbol_conf.initialized = false;
 }
 int machines__create_kernel_maps(struct rb_root *machines, pid_t pid)
 {
 	struct machine *machine = machines__findnew(machines, pid);
 	if (machine == NULL)
 		return -1;
 	return machine__create_kernel_maps(machine);
 }
 static int hex(char ch)
 {
 	if ((ch >= '0') && (ch <= '9'))
 		return ch - '0';
 	if ((ch >= 'a') && (ch <= 'f'))
 		return ch - 'a' + 10;
 	if ((ch >= 'A') && (ch <= 'F'))
 		return ch - 'A' + 10;
 	return -1;
 }
 /*
  * While we find nice hex chars, build a long_val.
  * Return number of chars processed.
  */
 int hex2u64(const char *ptr, u64 *long_val)
 {
 	const char *p = ptr;
 	*long_val = 0;
 	while (*p) {
 		const int hex_val = hex(*p);
 		if (hex_val < 0)
 			break;
 		*long_val = (*long_val << 4) | hex_val;
 		p++;
 	}
 	return p - ptr;
 }
 char *strxfrchar(char *s, char from, char to)
 {
 	char *p = s;
 	while ((p = strchr(p, from)) != NULL)
 		*p++ = to;
 	return s;
 }
 int machines__create_guest_kernel_maps(struct rb_root *machines)
 {
 	int ret = 0;
 	struct dirent **namelist = NULL;
 	int i, items = 0;
 	char path[PATH_MAX];
 	pid_t pid;
 	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 = atoi(namelist[i]->d_name);
 			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_guest_kernel_maps(struct rb_root *machines)
 {
 	struct rb_node *next = rb_first(machines);
 	while (next) {
 		struct machine *pos = rb_entry(next, struct machine, rb_node);
 		next = rb_next(&pos->rb_node);
 		rb_erase(&pos->rb_node, machines);
 		machine__delete(pos);
 	}
 }
 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);
 		map__reloc_vmlinux(map);
 	}
 	return ret;
 }