lael-labs/linux

arch/x86/Kconfig+1−1

 	select HAVE_UNSTABLE_SCHED_CLOCK
 	select HAVE_IDE
 	select HAVE_OPROFILE
+	select HAVE_PERF_COUNTERS if (!M386 && !M486)
 	select HAVE_IOREMAP_PROT
 	select HAVE_KPROBES
 	select ARCH_WANT_OPTIONAL_GPIOLIB
 config X86_LOCAL_APIC
 	def_bool y
 	depends on X86_64 || SMP || X86_32_NON_STANDARD || X86_UP_APIC
-	select HAVE_PERF_COUNTERS if (!M386 && !M486)
 config X86_IO_APIC
 	def_bool y

arch/x86/kernel/cpu/perf_counter.c+33−7

 	int		num_counters_fixed;
 	int		counter_bits;
 	u64		counter_mask;
+	int		apic;
 	u64		max_period;
 	u64		intel_ctrl;
 };
 {
   [PERF_COUNT_HW_CPU_CYCLES]		= 0x0079,
   [PERF_COUNT_HW_INSTRUCTIONS]		= 0x00c0,
-  [PERF_COUNT_HW_CACHE_REFERENCES]	= 0x0000,
+  [PERF_COUNT_HW_CACHE_REFERENCES]	= 0x0f2e,
-  [PERF_COUNT_HW_CACHE_MISSES]		= 0x0000,
+  [PERF_COUNT_HW_CACHE_MISSES]		= 0x012e,
   [PERF_COUNT_HW_BRANCH_INSTRUCTIONS]	= 0x00c4,
   [PERF_COUNT_HW_BRANCH_MISSES]		= 0x00c5,
   [PERF_COUNT_HW_BUS_CYCLES]		= 0x0062,
 static bool reserve_pmc_hardware(void)
 {
+#ifdef CONFIG_X86_LOCAL_APIC
 	int i;
 	if (nmi_watchdog == NMI_LOCAL_APIC)
 		if (!reserve_evntsel_nmi(x86_pmu.eventsel + i))
 			goto eventsel_fail;
 	}
+#endif
 	return true;
+#ifdef CONFIG_X86_LOCAL_APIC
 eventsel_fail:
 	for (i--; i >= 0; i--)
 		release_evntsel_nmi(x86_pmu.eventsel + i);
 		enable_lapic_nmi_watchdog();
 	return false;
+#endif
 }
 static void release_pmc_hardware(void)
 {
+#ifdef CONFIG_X86_LOCAL_APIC
 	int i;
 	for (i = 0; i < x86_pmu.num_counters; i++) {
 	if (nmi_watchdog == NMI_LOCAL_APIC)
 		enable_lapic_nmi_watchdog();
+#endif
 }
 static void hw_perf_counter_destroy(struct perf_counter *counter)
 		hwc->sample_period = x86_pmu.max_period;
 		hwc->last_period = hwc->sample_period;
 		atomic64_set(&hwc->period_left, hwc->sample_period);
+	} else {
+		/*
+		 * If we have a PMU initialized but no APIC
+		 * interrupts, we cannot sample hardware
+		 * counters (user-space has to fall back and
+		 * sample via a hrtimer based software counter):
+		 */
+		if (!x86_pmu.apic)
+			return -EOPNOTSUPP;
 	}
 	counter->destroy = hw_perf_counter_destroy;
 void set_perf_counter_pending(void)
 {
+#ifdef CONFIG_X86_LOCAL_APIC
 	apic->send_IPI_self(LOCAL_PENDING_VECTOR);
+#endif
 }
 void perf_counters_lapic_init(void)
 {
-	if (!x86_pmu_initialized())
+#ifdef CONFIG_X86_LOCAL_APIC
+	if (!x86_pmu.apic || !x86_pmu_initialized())
 		return;
 	/*
 	 * Always use NMI for PMU
 	 */
 	apic_write(APIC_LVTPC, APIC_DM_NMI);
+#endif
 }
 static int __kprobes
 	regs = args->regs;
+#ifdef CONFIG_X86_LOCAL_APIC
 	apic_write(APIC_LVTPC, APIC_DM_NMI);
+#endif
 	/*
 	 * Can't rely on the handled return value to say it was our NMI, two
 	 * counters could trigger 'simultaneously' raising two back-to-back NMIs.
 	.event_map		= p6_pmu_event_map,
 	.raw_event		= p6_pmu_raw_event,
 	.max_events		= ARRAY_SIZE(p6_perfmon_event_map),
+	.apic			= 1,
 	.max_period		= (1ULL << 31) - 1,
 	.version		= 0,
 	.num_counters		= 2,
 	.event_map		= intel_pmu_event_map,
 	.raw_event		= intel_pmu_raw_event,
 	.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
 	.num_counters		= 4,
 	.counter_bits		= 48,
 	.counter_mask		= (1ULL << 48) - 1,
+	.apic			= 1,
 	/* use highest bit to detect overflow */
 	.max_period		= (1ULL << 47) - 1,
 };
 		return -ENODEV;
 	}
+	x86_pmu = p6_pmu;
 	if (!cpu_has_apic) {
-		pr_info("no Local APIC, try rebooting with lapic");
+		pr_info("no APIC, boot with the \"lapic\" boot parameter to force-enable it.\n");
-		return -ENODEV;
+		pr_info("no hardware sampling interrupt available.\n");
+		x86_pmu.apic = 0;
 	}
-	x86_pmu				= p6_pmu;
 	return 0;
 }

include/linux/perf_counter.h+38−11

 	PERF_SAMPLE_TID				= 1U << 1,
 	PERF_SAMPLE_TIME			= 1U << 2,
 	PERF_SAMPLE_ADDR			= 1U << 3,
-	PERF_SAMPLE_GROUP			= 1U << 4,
+	PERF_SAMPLE_READ			= 1U << 4,
 	PERF_SAMPLE_CALLCHAIN			= 1U << 5,
 	PERF_SAMPLE_ID				= 1U << 6,
 	PERF_SAMPLE_CPU				= 1U << 7,
 };
 /*
- * Bits that can be set in attr.read_format to request that
+ * The format of the data returned by read() on a perf counter fd,
- * reads on the counter should return the indicated quantities,
+ * as specified by attr.read_format:
- * in increasing order of bit value, after the counter value.
+ *
+ * struct read_format {
+ * 	{ u64		value;
+ * 	  { u64		time_enabled; } && PERF_FORMAT_ENABLED
+ * 	  { u64		time_running; } && PERF_FORMAT_RUNNING
+ * 	  { u64		id;           } && PERF_FORMAT_ID
+ * 	} && !PERF_FORMAT_GROUP
+ *
+ * 	{ u64		nr;
+ * 	  { u64		time_enabled; } && PERF_FORMAT_ENABLED
+ * 	  { u64		time_running; } && PERF_FORMAT_RUNNING
+ * 	  { u64		value;
+ * 	    { u64	id;           } && PERF_FORMAT_ID
+ * 	  }		cntr[nr];
+ * 	} && PERF_FORMAT_GROUP
+ * };
  */
 enum perf_counter_read_format {
 	PERF_FORMAT_TOTAL_TIME_ENABLED		= 1U << 0,
 	PERF_FORMAT_TOTAL_TIME_RUNNING		= 1U << 1,
 	PERF_FORMAT_ID				= 1U << 2,
+	PERF_FORMAT_GROUP			= 1U << 3,
-	PERF_FORMAT_MAX = 1U << 3, 		/* non-ABI */
+	PERF_FORMAT_MAX = 1U << 4, 		/* non-ABI */
 };
 #define PERF_ATTR_SIZE_VER0	64	/* sizeof first published struct */
 	 * struct {
 	 * 	struct perf_event_header	header;
 	 * 	u32				pid, tid;
-	 * 	u64				value;
+	 *
-	 * 	{ u64		time_enabled; 	} && PERF_FORMAT_ENABLED
+	 * 	struct read_format		values;
-	 * 	{ u64		time_running; 	} && PERF_FORMAT_RUNNING
-	 * 	{ u64		parent_id;	} && PERF_FORMAT_ID
 	 * };
 	 */
 	PERF_EVENT_READ			= 8,
 	 *	{ u32			cpu, res; } && PERF_SAMPLE_CPU
 	 * 	{ u64			period;   } && PERF_SAMPLE_PERIOD
 	 *
-	 *	{ u64			nr;
+	 *	{ struct read_format	values;	  } && PERF_SAMPLE_READ
-	 *	  { u64 id, val; }	cnt[nr];  } && PERF_SAMPLE_GROUP
 	 *
 	 *	{ u64			nr,
 	 *	  u64			ips[nr];  } && PERF_SAMPLE_CALLCHAIN
+	 *
+	 * 	#
+	 * 	# The RAW record below is opaque data wrt the ABI
+	 * 	#
+	 * 	# That is, the ABI doesn't make any promises wrt to
+	 * 	# the stability of its content, it may vary depending
+	 * 	# on event, hardware, kernel version and phase of
+	 * 	# the moon.
+	 * 	#
+	 * 	# In other words, PERF_SAMPLE_RAW contents are not an ABI.
+	 * 	#
+	 *
 	 *	{ u32			size;
 	 *	  char                  data[size];}&& PERF_SAMPLE_RAW
 	 * };
 extern int perf_counter_overflow(struct perf_counter *counter, int nmi,
 				 struct perf_sample_data *data);
+extern void perf_counter_output(struct perf_counter *counter, int nmi,
+				struct perf_sample_data *data);
 /*
  * Return 1 for a software counter, 0 for a hardware counter

kernel/perf_counter.c+236−102

@@ -88,6 +88,7 @@ void __weak hw_perf_disable(void) { barrier(); } · 87 unmodified lines
88	void __weak hw_perf_enable(void) { barrier(); }	88	void __weak hw_perf_enable(void) { barrier(); }
89		89
90	void __weak hw_perf_counter_setup(int cpu) { barrier(); }	90	void __weak hw_perf_counter_setup(int cpu) { barrier(); }
		91	void __weak hw_perf_counter_setup_online(int cpu) { barrier(); }
91		92
92	int __weak	93	int __weak
93	hw_perf_group_sched_in(struct perf_counter *group_leader,	94	hw_perf_group_sched_in(struct perf_counter *group_leader,
@@ -306,6 +307,10 @@ counter_sched_out(struct perf_counter *counter, · 212 unmodified lines
306	return;	307	return;
307		308
308	counter->state = PERF_COUNTER_STATE_INACTIVE;	309	counter->state = PERF_COUNTER_STATE_INACTIVE;
		310	if (counter->pending_disable) {
		311	counter->pending_disable = 0;
		312	counter->state = PERF_COUNTER_STATE_OFF;
		313	}
309	counter->tstamp_stopped = ctx->time;	314	counter->tstamp_stopped = ctx->time;
310	counter->pmu->disable(counter);	315	counter->pmu->disable(counter);
311	counter->oncpu = -1;	316	counter->oncpu = -1;
@@ -1691,7 +1696,32 @@ static int perf_release(struct inode inode, struct file file) · 1379 unmodified lines
1691	return 0;	1696	return 0;
1692	}	1697	}
1693		1698
1694	static u64 perf_counter_read_tree(struct perf_counter *counter)	1699	static int perf_counter_read_size(struct perf_counter *counter)
		1700	{
		1701	int entry = sizeof(u64); /* value */
		1702	int size = 0;
		1703	int nr = 1;
		1704
		1705	if (counter->attr.read_format & PERF_FORMAT_TOTAL_TIME_ENABLED)
		1706	size += sizeof(u64);
		1707
		1708	if (counter->attr.read_format & PERF_FORMAT_TOTAL_TIME_RUNNING)
		1709	size += sizeof(u64);
		1710
		1711	if (counter->attr.read_format & PERF_FORMAT_ID)
		1712	entry += sizeof(u64);
		1713
		1714	if (counter->attr.read_format & PERF_FORMAT_GROUP) {
		1715	nr += counter->group_leader->nr_siblings;
		1716	size += sizeof(u64);
		1717	}
		1718
		1719	size += entry * nr;
		1720
		1721	return size;
		1722	}
		1723
		1724	static u64 perf_counter_read_value(struct perf_counter *counter)
1695	{	1725	{
1696	struct perf_counter *child;	1726	struct perf_counter *child;
1697	u64 total = 0;	1727	u64 total = 0;
@@ -1703,14 +1733,96 @@ static u64 perf_counter_read_tree(struct perf_counter *counter) · 5 unmodified lines
1703	return total;	1733	return total;
1704	}	1734	}
1705		1735
		1736	static int perf_counter_read_entry(struct perf_counter *counter,
		1737	u64 read_format, char __user *buf)
		1738	{
		1739	int n = 0, count = 0;
		1740	u64 values[2];
		1741
		1742	values[n++] = perf_counter_read_value(counter);
		1743	if (read_format & PERF_FORMAT_ID)
		1744	values[n++] = primary_counter_id(counter);
		1745
		1746	count = n * sizeof(u64);
		1747
		1748	if (copy_to_user(buf, values, count))
		1749	return -EFAULT;
		1750
		1751	return count;
		1752	}
		1753
		1754	static int perf_counter_read_group(struct perf_counter *counter,
		1755	u64 read_format, char __user *buf)
		1756	{
		1757	struct perf_counter leader = counter->group_leader, sub;
		1758	int n = 0, size = 0, err = -EFAULT;
		1759	u64 values[3];
		1760
		1761	values[n++] = 1 + leader->nr_siblings;
		1762	if (read_format & PERF_FORMAT_TOTAL_TIME_ENABLED) {
		1763	values[n++] = leader->total_time_enabled +
		1764	atomic64_read(&leader->child_total_time_enabled);
		1765	}
		1766	if (read_format & PERF_FORMAT_TOTAL_TIME_RUNNING) {
		1767	values[n++] = leader->total_time_running +
		1768	atomic64_read(&leader->child_total_time_running);
		1769	}
		1770
		1771	size = n * sizeof(u64);
		1772
		1773	if (copy_to_user(buf, values, size))
		1774	return -EFAULT;
		1775
		1776	err = perf_counter_read_entry(leader, read_format, buf + size);
		1777	if (err < 0)
		1778	return err;
		1779
		1780	size += err;
		1781
		1782	list_for_each_entry(sub, &leader->sibling_list, list_entry) {
		1783	err = perf_counter_read_entry(counter, read_format,
		1784	buf + size);
		1785	if (err < 0)
		1786	return err;
		1787
		1788	size += err;
		1789	}
		1790
		1791	return size;
		1792	}
		1793
		1794	static int perf_counter_read_one(struct perf_counter *counter,
		1795	u64 read_format, char __user *buf)
		1796	{
		1797	u64 values[4];
		1798	int n = 0;
		1799
		1800	values[n++] = perf_counter_read_value(counter);
		1801	if (read_format & PERF_FORMAT_TOTAL_TIME_ENABLED) {
		1802	values[n++] = counter->total_time_enabled +
		1803	atomic64_read(&counter->child_total_time_enabled);
		1804	}
		1805	if (read_format & PERF_FORMAT_TOTAL_TIME_RUNNING) {
		1806	values[n++] = counter->total_time_running +
		1807	atomic64_read(&counter->child_total_time_running);
		1808	}
		1809	if (read_format & PERF_FORMAT_ID)
		1810	values[n++] = primary_counter_id(counter);
		1811
		1812	if (copy_to_user(buf, values, n * sizeof(u64)))
		1813	return -EFAULT;
		1814
		1815	return n * sizeof(u64);
		1816	}
		1817
1706	/*	1818	/*
1707	* Read the performance counter - simple non blocking version for now	1819	* Read the performance counter - simple non blocking version for now
1708	*/	1820	*/
1709	static ssize_t	1821	static ssize_t
1710	perf_read_hw(struct perf_counter counter, char __user buf, size_t count)	1822	perf_read_hw(struct perf_counter counter, char __user buf, size_t count)
1711	{	1823	{
1712	u64 values[4];	1824	u64 read_format = counter->attr.read_format;
1713	int n;	1825	int ret;
1714		1826
1715	/*	1827	/*
1716	* Return end-of-file for a read on a counter that is in	1828	* Return end-of-file for a read on a counter that is in
@@ -1720,28 +1832,18 @@ perf_read_hw(struct perf_counter counter, char __user buf, size_t count) · 3 unmodified lines
1720	if (counter->state == PERF_COUNTER_STATE_ERROR)	1832	if (counter->state == PERF_COUNTER_STATE_ERROR)
1721	return 0;	1833	return 0;
1722		1834
		1835	if (count < perf_counter_read_size(counter))
		1836	return -ENOSPC;
		1837
1723	WARN_ON_ONCE(counter->ctx->parent_ctx);	1838	WARN_ON_ONCE(counter->ctx->parent_ctx);
1724	mutex_lock(&counter->child_mutex);	1839	mutex_lock(&counter->child_mutex);
1725	values[0] = perf_counter_read_tree(counter);	1840	if (read_format & PERF_FORMAT_GROUP)
1726	n = 1;	1841	ret = perf_counter_read_group(counter, read_format, buf);
1727	if (counter->attr.read_format & PERF_FORMAT_TOTAL_TIME_ENABLED)	1842	else
1728	values[n++] = counter->total_time_enabled +	1843	ret = perf_counter_read_one(counter, read_format, buf);
1729	atomic64_read(&counter->child_total_time_enabled);
1730	if (counter->attr.read_format & PERF_FORMAT_TOTAL_TIME_RUNNING)
1731	values[n++] = counter->total_time_running +
1732	atomic64_read(&counter->child_total_time_running);
1733	if (counter->attr.read_format & PERF_FORMAT_ID)
1734	values[n++] = primary_counter_id(counter);
1735	mutex_unlock(&counter->child_mutex);	1844	mutex_unlock(&counter->child_mutex);
1736		1845
1737	if (count < n * sizeof(u64))	1846	return ret;
1738	return -EINVAL;
1739	count = n * sizeof(u64);
1740
1741	if (copy_to_user(buf, values, count))
1742	return -EFAULT;
1743
1744	return count;
1745	}	1847	}
1746		1848
1747	static ssize_t	1849	static ssize_t
@@ -2245,7 +2347,7 @@ static void perf_pending_counter(struct perf_pending_entry *entry) · 497 unmodified lines
2245		2347
2246	if (counter->pending_disable) {	2348	if (counter->pending_disable) {
2247	counter->pending_disable = 0;	2349	counter->pending_disable = 0;
2248	perf_counter_disable(counter);	2350	__perf_counter_disable(counter);
2249	}	2351	}
2250		2352
2251	if (counter->pending_wakeup) {	2353	if (counter->pending_wakeup) {
@@ -2630,7 +2732,80 @@ static u32 perf_counter_tid(struct perf_counter counter, struct task_struct p) · 378 unmodified lines
2630	return task_pid_nr_ns(p, counter->ns);	2732	return task_pid_nr_ns(p, counter->ns);
2631	}	2733	}
2632		2734
2633	static void perf_counter_output(struct perf_counter *counter, int nmi,	2735	static void perf_output_read_one(struct perf_output_handle *handle,
		2736	struct perf_counter *counter)
		2737	{
		2738	u64 read_format = counter->attr.read_format;
		2739	u64 values[4];
		2740	int n = 0;
		2741
		2742	values[n++] = atomic64_read(&counter->count);
		2743	if (read_format & PERF_FORMAT_TOTAL_TIME_ENABLED) {
		2744	values[n++] = counter->total_time_enabled +
		2745	atomic64_read(&counter->child_total_time_enabled);
		2746	}
		2747	if (read_format & PERF_FORMAT_TOTAL_TIME_RUNNING) {
		2748	values[n++] = counter->total_time_running +
		2749	atomic64_read(&counter->child_total_time_running);
		2750	}
		2751	if (read_format & PERF_FORMAT_ID)
		2752	values[n++] = primary_counter_id(counter);
		2753
		2754	perf_output_copy(handle, values, n * sizeof(u64));
		2755	}
		2756
		2757	/*
		2758	* XXX PERF_FORMAT_GROUP vs inherited counters seems difficult.
		2759	*/
		2760	static void perf_output_read_group(struct perf_output_handle *handle,
		2761	struct perf_counter *counter)
		2762	{
		2763	struct perf_counter leader = counter->group_leader, sub;
		2764	u64 read_format = counter->attr.read_format;
		2765	u64 values[5];
		2766	int n = 0;
		2767
		2768	values[n++] = 1 + leader->nr_siblings;
		2769
		2770	if (read_format & PERF_FORMAT_TOTAL_TIME_ENABLED)
		2771	values[n++] = leader->total_time_enabled;
		2772
		2773	if (read_format & PERF_FORMAT_TOTAL_TIME_RUNNING)
		2774	values[n++] = leader->total_time_running;
		2775
		2776	if (leader != counter)
		2777	leader->pmu->read(leader);
		2778
		2779	values[n++] = atomic64_read(&leader->count);
		2780	if (read_format & PERF_FORMAT_ID)
		2781	values[n++] = primary_counter_id(leader);
		2782
		2783	perf_output_copy(handle, values, n * sizeof(u64));
		2784
		2785	list_for_each_entry(sub, &leader->sibling_list, list_entry) {
		2786	n = 0;
		2787
		2788	if (sub != counter)
		2789	sub->pmu->read(sub);
		2790
		2791	values[n++] = atomic64_read(&sub->count);
		2792	if (read_format & PERF_FORMAT_ID)
		2793	values[n++] = primary_counter_id(sub);
		2794
		2795	perf_output_copy(handle, values, n * sizeof(u64));
		2796	}
		2797	}
		2798
		2799	static void perf_output_read(struct perf_output_handle *handle,
		2800	struct perf_counter *counter)
		2801	{
		2802	if (counter->attr.read_format & PERF_FORMAT_GROUP)
		2803	perf_output_read_group(handle, counter);
		2804	else
		2805	perf_output_read_one(handle, counter);
		2806	}
		2807
		2808	void perf_counter_output(struct perf_counter *counter, int nmi,
2634	struct perf_sample_data *data)	2809	struct perf_sample_data *data)
2635	{	2810	{
2636	int ret;	2811	int ret;
@@ -2641,10 +2816,6 @@ static void perf_counter_output(struct perf_counter *counter, int nmi, · 4 unmodified lines
2641	struct {	2816	struct {
2642	u32 pid, tid;	2817	u32 pid, tid;
2643	} tid_entry;	2818	} tid_entry;
2644	struct {
2645	u64 id;
2646	u64 counter;
2647	} group_entry;
2648	struct perf_callchain_entry *callchain = NULL;	2819	struct perf_callchain_entry *callchain = NULL;
2649	int callchain_size = 0;	2820	int callchain_size = 0;
2650	u64 time;	2821	u64 time;
@@ -2699,10 +2870,8 @@ static void perf_counter_output(struct perf_counter *counter, int nmi, · 48 unmodified lines
2699	if (sample_type & PERF_SAMPLE_PERIOD)	2870	if (sample_type & PERF_SAMPLE_PERIOD)
2700	header.size += sizeof(u64);	2871	header.size += sizeof(u64);
2701		2872
2702	if (sample_type & PERF_SAMPLE_GROUP) {	2873	if (sample_type & PERF_SAMPLE_READ)
2703	header.size += sizeof(u64) +	2874	header.size += perf_counter_read_size(counter);
2704	counter->nr_siblings * sizeof(group_entry);
2705	}
2706		2875
2707	if (sample_type & PERF_SAMPLE_CALLCHAIN) {	2876	if (sample_type & PERF_SAMPLE_CALLCHAIN) {
2708	callchain = perf_callchain(data->regs);	2877	callchain = perf_callchain(data->regs);
@@ -2759,26 +2928,8 @@ static void perf_counter_output(struct perf_counter *counter, int nmi, · 50 unmodified lines
2759	if (sample_type & PERF_SAMPLE_PERIOD)	2928	if (sample_type & PERF_SAMPLE_PERIOD)
2760	perf_output_put(&handle, data->period);	2929	perf_output_put(&handle, data->period);
2761		2930
2762	/*	2931	if (sample_type & PERF_SAMPLE_READ)
2763	* XXX PERF_SAMPLE_GROUP vs inherited counters seems difficult.	2932	perf_output_read(&handle, counter);
2764	*/
2765	if (sample_type & PERF_SAMPLE_GROUP) {
2766	struct perf_counter leader, sub;
2767	u64 nr = counter->nr_siblings;
2768
2769	perf_output_put(&handle, nr);
2770
2771	leader = counter->group_leader;
2772	list_for_each_entry(sub, &leader->sibling_list, list_entry) {
2773	if (sub != counter)
2774	sub->pmu->read(sub);
2775
2776	group_entry.id = primary_counter_id(sub);
2777	group_entry.counter = atomic64_read(&sub->count);
2778
2779	perf_output_put(&handle, group_entry);
2780	}
2781	}
2782		2933
2783	if (sample_type & PERF_SAMPLE_CALLCHAIN) {	2934	if (sample_type & PERF_SAMPLE_CALLCHAIN) {
2784	if (callchain)	2935	if (callchain)
@@ -2817,8 +2968,6 @@ struct perf_read_event { · 32 unmodified lines
2817		2968
2818	u32 pid;	2969	u32 pid;
2819	u32 tid;	2970	u32 tid;
2820	u64 value;
2821	u64 format[3];
2822	};	2971	};
2823		2972
2824	static void	2973	static void
@@ -2830,34 +2979,20 @@ perf_counter_read_event(struct perf_counter *counter, · 5 unmodified lines
2830	.header = {	2979	.header = {
2831	.type = PERF_EVENT_READ,	2980	.type = PERF_EVENT_READ,
2832	.misc = 0,	2981	.misc = 0,
2833	.size = sizeof(event) - sizeof(event.format),	2982	.size = sizeof(event) + perf_counter_read_size(counter),
2834	},	2983	},
2835	.pid = perf_counter_pid(counter, task),	2984	.pid = perf_counter_pid(counter, task),
2836	.tid = perf_counter_tid(counter, task),	2985	.tid = perf_counter_tid(counter, task),
2837	.value = atomic64_read(&counter->count),
2838	};	2986	};
2839	int ret, i = 0;	2987	int ret;
2840
2841	if (counter->attr.read_format & PERF_FORMAT_TOTAL_TIME_ENABLED) {
2842	event.header.size += sizeof(u64);
2843	event.format[i++] = counter->total_time_enabled;
2844	}
2845
2846	if (counter->attr.read_format & PERF_FORMAT_TOTAL_TIME_RUNNING) {
2847	event.header.size += sizeof(u64);
2848	event.format[i++] = counter->total_time_running;
2849	}
2850
2851	if (counter->attr.read_format & PERF_FORMAT_ID) {
2852	event.header.size += sizeof(u64);
2853	event.format[i++] = primary_counter_id(counter);
2854	}
2855		2988
2856	ret = perf_output_begin(&handle, counter, event.header.size, 0, 0);	2989	ret = perf_output_begin(&handle, counter, event.header.size, 0, 0);
2857	if (ret)	2990	if (ret)
2858	return;	2991	return;
2859		2992
2860	perf_output_copy(&handle, &event, event.header.size);	2993	perf_output_put(&handle, event);
		2994	perf_output_read(&handle, counter);
		2995
2861	perf_output_end(&handle);	2996	perf_output_end(&handle);
2862	}	2997	}
2863		2998
@@ -2893,10 +3028,10 @@ static void perf_counter_task_output(struct perf_counter *counter, · 29 unmodified lines
2893	return;	3028	return;
2894		3029
2895	task_event->event.pid = perf_counter_pid(counter, task);	3030	task_event->event.pid = perf_counter_pid(counter, task);
2896	task_event->event.ppid = perf_counter_pid(counter, task->real_parent);	3031	task_event->event.ppid = perf_counter_pid(counter, current);
2897		3032
2898	task_event->event.tid = perf_counter_tid(counter, task);	3033	task_event->event.tid = perf_counter_tid(counter, task);
2899	task_event->event.ptid = perf_counter_tid(counter, task->real_parent);	3034	task_event->event.ptid = perf_counter_tid(counter, current);
2900		3035
2901	perf_output_put(&handle, task_event->event);	3036	perf_output_put(&handle, task_event->event);
2902	perf_output_end(&handle);	3037	perf_output_end(&handle);
@@ -3443,40 +3578,32 @@ static void perf_swcounter_add(struct perf_counter *counter, u64 nr, · 540 unmodified lines
3443		3578
3444	static int perf_swcounter_is_counting(struct perf_counter *counter)	3579	static int perf_swcounter_is_counting(struct perf_counter *counter)
3445	{	3580	{
3446	struct perf_counter_context *ctx;	3581	/*
3447	unsigned long flags;	3582	* The counter is active, we're good!
3448	int count;	3583	*/
3449
3450	if (counter->state == PERF_COUNTER_STATE_ACTIVE)	3584	if (counter->state == PERF_COUNTER_STATE_ACTIVE)
3451	return 1;	3585	return 1;
3452		3586
		3587	/*
		3588	* The counter is off/error, not counting.
		3589	*/
3453	if (counter->state != PERF_COUNTER_STATE_INACTIVE)	3590	if (counter->state != PERF_COUNTER_STATE_INACTIVE)
3454	return 0;	3591	return 0;
3455		3592
3456	/*	3593	/*
3457	* If the counter is inactive, it could be just because	3594	* The counter is inactive, if the context is active
3458	* its task is scheduled out, or because it's in a group	3595	* we're part of a group that didn't make it on the 'pmu',
3459	* which could not go on the PMU. We want to count in	3596	* not counting.
3460	* the first case but not the second. If the context is
3461	* currently active then an inactive software counter must
3462	* be the second case. If it's not currently active then
3463	* we need to know whether the counter was active when the
3464	* context was last active, which we can determine by
3465	* comparing counter->tstamp_stopped with ctx->time.
3466	*
3467	* We are within an RCU read-side critical section,
3468	* which protects the existence of *ctx.
3469	*/	3597	*/
3470	ctx = counter->ctx;	3598	if (counter->ctx->is_active)
3471	spin_lock_irqsave(&ctx->lock, flags);	3599	return 0;
3472	count = 1;	3600
3473	/* Re-check state now we have the lock */	3601	/*
3474	if (counter->state < PERF_COUNTER_STATE_INACTIVE \|\|	3602	* We're inactive and the context is too, this means the
3475	counter->ctx->is_active \|\|	3603	* task is scheduled out, we're counting events that happen
3476	counter->tstamp_stopped < ctx->time)	3604	* to us, like migration events.
3477	count = 0;	3605	*/
3478	spin_unlock_irqrestore(&ctx->lock, flags);	3606	return 1;
3479	return count;
3480	}	3607	}
3481		3608
3482	static int perf_swcounter_match(struct perf_counter *counter,	3609	static int perf_swcounter_match(struct perf_counter *counter,
@@ -3928,9 +4055,9 @@ perf_counter_alloc(struct perf_counter_attr *attr, · 445 unmodified lines
3928	atomic64_set(&hwc->period_left, hwc->sample_period);	4055	atomic64_set(&hwc->period_left, hwc->sample_period);
3929		4056
3930	/*	4057	/*
3931	* we currently do not support PERF_SAMPLE_GROUP on inherited counters	4058	* we currently do not support PERF_FORMAT_GROUP on inherited counters
3932	*/	4059	*/
3933	if (attr->inherit && (attr->sample_type & PERF_SAMPLE_GROUP))	4060	if (attr->inherit && (attr->read_format & PERF_FORMAT_GROUP))
3934	goto done;	4061	goto done;
3935		4062
3936	switch (attr->type) {	4063	switch (attr->type) {
@@ -4592,6 +4719,11 @@ perf_cpu_notify(struct notifier_block self, unsigned long action, void hcpu) · 655 unmodified lines
4592	perf_counter_init_cpu(cpu);	4719	perf_counter_init_cpu(cpu);
4593	break;	4720	break;
4594		4721
		4722	case CPU_ONLINE:
		4723	case CPU_ONLINE_FROZEN:
		4724	hw_perf_counter_setup_online(cpu);
		4725	break;
		4726
4595	case CPU_DOWN_PREPARE:	4727	case CPU_DOWN_PREPARE:
4596	case CPU_DOWN_PREPARE_FROZEN:	4728	case CPU_DOWN_PREPARE_FROZEN:
4597	perf_counter_exit_cpu(cpu);	4729	perf_counter_exit_cpu(cpu);
@@ -4616,6 +4748,8 @@ void __init perf_counter_init(void) · 18 unmodified lines
4616	{	4748	{
4617	perf_cpu_notify(&perf_cpu_nb, (unsigned long)CPU_UP_PREPARE,	4749	perf_cpu_notify(&perf_cpu_nb, (unsigned long)CPU_UP_PREPARE,
4618	(void *)(long)smp_processor_id());	4750	(void *)(long)smp_processor_id());
		4751	perf_cpu_notify(&perf_cpu_nb, (unsigned long)CPU_ONLINE,
		4752	(void *)(long)smp_processor_id());
4619	register_cpu_notifier(&perf_cpu_nb);	4753	register_cpu_notifier(&perf_cpu_nb);
4620	}	4754	}
4621		4755

tools/perf/Makefile+18−11

 ifdef NO_DEMANGLE
 	BASIC_CFLAGS += -DNO_DEMANGLE
 else
 	has_bfd := $(shell sh -c "(echo '\#include <bfd.h>'; echo 'int main(void) { bfd_demangle(0, 0, 0); return 0; }') | $(CC) -x c - $(ALL_CFLAGS) -o /dev/null $(ALL_LDFLAGS) -lbfd > /dev/null 2>&1 && echo y")
-	has_bfd_iberty := $(shell sh -c "(echo '\#include <bfd.h>'; echo 'int main(void) { bfd_demangle(0, 0, 0); return 0; }') | $(CC) -x c - $(ALL_CFLAGS) -o /dev/null $(ALL_LDFLAGS) -lbfd -liberty > /dev/null 2>&1 && echo y")
-	has_bfd_iberty_z := $(shell sh -c "(echo '\#include <bfd.h>'; echo 'int main(void) { bfd_demangle(0, 0, 0); return 0; }') | $(CC) -x c - $(ALL_CFLAGS) -o /dev/null $(ALL_LDFLAGS) -lbfd -liberty -lz > /dev/null 2>&1 && echo y")
 	ifeq ($(has_bfd),y)
 		EXTLIBS += -lbfd
-	else ifeq ($(has_bfd_iberty),y)
-		EXTLIBS += -lbfd -liberty
-	else ifeq ($(has_bfd_iberty_z),y)
-		EXTLIBS += -lbfd -liberty -lz
 	else
-		msg := $(warning No bfd.h/libbfd found, install binutils-dev[el] to gain symbol demangling)
+		has_bfd_iberty := $(shell sh -c "(echo '\#include <bfd.h>'; echo 'int main(void) { bfd_demangle(0, 0, 0); return 0; }') | $(CC) -x c - $(ALL_CFLAGS) -o /dev/null $(ALL_LDFLAGS) -lbfd -liberty > /dev/null 2>&1 && echo y")
-		BASIC_CFLAGS += -DNO_DEMANGLE
+		ifeq ($(has_bfd_iberty),y)
+			EXTLIBS += -lbfd -liberty
+		else
+			has_bfd_iberty_z := $(shell sh -c "(echo '\#include <bfd.h>'; echo 'int main(void) { bfd_demangle(0, 0, 0); return 0; }') | $(CC) -x c - $(ALL_CFLAGS) -o /dev/null $(ALL_LDFLAGS) -lbfd -liberty -lz > /dev/null 2>&1 && echo y")
+			ifeq ($(has_bfd_iberty_z),y)
+				EXTLIBS += -lbfd -liberty -lz
+			else
+				has_cplus_demangle := $(shell sh -c "(echo 'extern char *cplus_demangle(const char *, int);'; echo 'int main(void) { cplus_demangle(0, 0); return 0; }') | $(CC) -x c - $(ALL_CFLAGS) -o /dev/null $(ALL_LDFLAGS) -liberty > /dev/null 2>&1 && echo y")
+				ifeq ($(has_cplus_demangle),y)
+					EXTLIBS += -liberty
+					BASIC_CFLAGS += -DHAVE_CPLUS_DEMANGLE
+				else
+					msg := $(warning No bfd.h/libbfd found, install binutils-dev[el] to gain symbol demangling)
+					BASIC_CFLAGS += -DNO_DEMANGLE
+				endif
+			endif
+		endif
 	endif
 endif

tools/perf/builtin-list.c+2−1

 #include "perf.h"
-#include "util/parse-options.h"
 #include "util/parse-events.h"
+#include "util/cache.h"
 int cmd_list(int argc __used, const char **argv __used, const char *prefix __used)
 {
+	setup_pager();
 	print_events();
 	return 0;
 }

tools/perf/builtin-record.c+58−37

@@ -34,7 +34,9 @@ static int output; · 33 unmodified lines
34	static const char *output_name = "perf.data";	34	static const char *output_name = "perf.data";
35	static int group = 0;	35	static int group = 0;
36	static unsigned int realtime_prio = 0;	36	static unsigned int realtime_prio = 0;
		37	static int raw_samples = 0;
37	static int system_wide = 0;	38	static int system_wide = 0;
		39	static int profile_cpu = -1;
38	static pid_t target_pid = -1;	40	static pid_t target_pid = -1;
39	static int inherit = 1;	41	static int inherit = 1;
40	static int force = 0;	42	static int force = 0;
@@ -203,46 +205,48 @@ static void sig_atexit(void) · 162 unmodified lines
203	kill(getpid(), signr);	205	kill(getpid(), signr);
204	}	206	}
205		207
206	static void pid_synthesize_comm_event(pid_t pid, int full)	208	static pid_t pid_synthesize_comm_event(pid_t pid, int full)
207	{	209	{
208	struct comm_event comm_ev;	210	struct comm_event comm_ev;
209	char filename[PATH_MAX];	211	char filename[PATH_MAX];
210	char bf[BUFSIZ];	212	char bf[BUFSIZ];
211	int fd;	213	FILE *fp;
212	size_t size;	214	size_t size = 0;
213	char field, sep;
214	DIR *tasks;	215	DIR *tasks;
215	struct dirent dirent, *next;	216	struct dirent dirent, *next;
		217	pid_t tgid = 0;
216		218
217	snprintf(filename, sizeof(filename), "/proc/%d/stat", pid);	219	snprintf(filename, sizeof(filename), "/proc/%d/status", pid);
218		220
219	fd = open(filename, O_RDONLY);	221	fp = fopen(filename, "r");
220	if (fd < 0) {	222	if (fd == NULL) {
221	/*	223	/*
222	* We raced with a task exiting - just return:	224	* We raced with a task exiting - just return:
223	*/	225	*/
224	if (verbose)	226	if (verbose)
225	fprintf(stderr, "couldn't open %s\n", filename);	227	fprintf(stderr, "couldn't open %s\n", filename);
226	return;	228	return 0;
227	}
228	if (read(fd, bf, sizeof(bf)) < 0) {
229	fprintf(stderr, "couldn't read %s\n", filename);
230	exit(EXIT_FAILURE);
231	}	229	}
232	close(fd);
233		230
234	/* 9027 (cat) R 6747 9027 6747 34816 9027 ... */
235	memset(&comm_ev, 0, sizeof(comm_ev));	231	memset(&comm_ev, 0, sizeof(comm_ev));
236	field = strchr(bf, '(');	232	while (!comm_ev.comm[0] \|\| !comm_ev.pid) {
237	if (field == NULL)	233	if (fgets(bf, sizeof(bf), fp) == NULL)
238	goto out_failure;	234	goto out_failure;
239	sep = strchr(++field, ')');	235
240	if (sep == NULL)	236	if (memcmp(bf, "Name:", 5) == 0) {
241	goto out_failure;	237	char *name = bf + 5;
242	size = sep - field;	238	while (name && isspace(name))
243	memcpy(comm_ev.comm, field, size++);	239	++name;
244		240	size = strlen(name) - 1;
245	comm_ev.pid = pid;	241	memcpy(comm_ev.comm, name, size++);
		242	} else if (memcmp(bf, "Tgid:", 5) == 0) {
		243	char *tgids = bf + 5;
		244	while (tgids && isspace(tgids))
		245	++tgids;
		246	tgid = comm_ev.pid = atoi(tgids);
		247	}
		248	}
		249
246	comm_ev.header.type = PERF_EVENT_COMM;	250	comm_ev.header.type = PERF_EVENT_COMM;
247	size = ALIGN(size, sizeof(u64));	251	size = ALIGN(size, sizeof(u64));
248	comm_ev.header.size = sizeof(comm_ev) - (sizeof(comm_ev.comm) - size);	252	comm_ev.header.size = sizeof(comm_ev) - (sizeof(comm_ev.comm) - size);
@@ -251,7 +255,7 @@ static void pid_synthesize_comm_event(pid_t pid, int full) · 2 unmodified lines
251	comm_ev.tid = pid;	255	comm_ev.tid = pid;
252		256
253	write_output(&comm_ev, comm_ev.header.size);	257	write_output(&comm_ev, comm_ev.header.size);
254	return;	258	goto out_fclose;
255	}	259	}
256		260
257	snprintf(filename, sizeof(filename), "/proc/%d/task", pid);	261	snprintf(filename, sizeof(filename), "/proc/%d/task", pid);
@@ -268,7 +272,10 @@ static void pid_synthesize_comm_event(pid_t pid, int full) · 10 unmodified lines
268	write_output(&comm_ev, comm_ev.header.size);	272	write_output(&comm_ev, comm_ev.header.size);
269	}	273	}
270	closedir(tasks);	274	closedir(tasks);
271	return;	275
		276	out_fclose:
		277	fclose(fp);
		278	return tgid;
272		279
273	out_failure:	280	out_failure:
274	fprintf(stderr, "couldn't get COMM and pgid, malformed %s\n",	281	fprintf(stderr, "couldn't get COMM and pgid, malformed %s\n",
@@ -276,7 +283,7 @@ out_failure: · 1 unmodified line
276	exit(EXIT_FAILURE);	283	exit(EXIT_FAILURE);
277	}	284	}
278		285
279	static void pid_synthesize_mmap_samples(pid_t pid)	286	static void pid_synthesize_mmap_samples(pid_t pid, pid_t tgid)
280	{	287	{
281	char filename[PATH_MAX];	288	char filename[PATH_MAX];
282	FILE *fp;	289	FILE *fp;
@@ -328,7 +335,7 @@ static void pid_synthesize_mmap_samples(pid_t pid) · 45 unmodified lines
328	mmap_ev.len -= mmap_ev.start;	335	mmap_ev.len -= mmap_ev.start;
329	mmap_ev.header.size = (sizeof(mmap_ev) -	336	mmap_ev.header.size = (sizeof(mmap_ev) -
330	(sizeof(mmap_ev.filename) - size));	337	(sizeof(mmap_ev.filename) - size));
331	mmap_ev.pid = pid;	338	mmap_ev.pid = tgid;
332	mmap_ev.tid = pid;	339	mmap_ev.tid = pid;
333		340
334	write_output(&mmap_ev, mmap_ev.header.size);	341	write_output(&mmap_ev, mmap_ev.header.size);
@@ -347,14 +354,14 @@ static void synthesize_all(void) · 12 unmodified lines
347		354
348	while (!readdir_r(proc, &dirent, &next) && next) {	355	while (!readdir_r(proc, &dirent, &next) && next) {
349	char *end;	356	char *end;
350	pid_t pid;	357	pid_t pid, tgid;
351		358
352	pid = strtol(dirent.d_name, &end, 10);	359	pid = strtol(dirent.d_name, &end, 10);
353	if (end) / only interested in proper numerical dirents */	360	if (end) / only interested in proper numerical dirents */
354	continue;	361	continue;
355		362
356	pid_synthesize_comm_event(pid, 1);	363	tgid = pid_synthesize_comm_event(pid, 1);
357	pid_synthesize_mmap_samples(pid);	364	pid_synthesize_mmap_samples(pid, tgid);
358	}	365	}
359		366
360	closedir(proc);	367	closedir(proc);
@@ -392,7 +399,7 @@ static void create_counter(int counter, int cpu, pid_t pid) · 31 unmodified lines
392	PERF_FORMAT_TOTAL_TIME_RUNNING \|	399	PERF_FORMAT_TOTAL_TIME_RUNNING \|
393	PERF_FORMAT_ID;	400	PERF_FORMAT_ID;
394		401
395	attr->sample_type = PERF_SAMPLE_IP \| PERF_SAMPLE_TID;	402	attr->sample_type \|= PERF_SAMPLE_IP \| PERF_SAMPLE_TID;
396		403
397	if (freq) {	404	if (freq) {
398	attr->sample_type \|= PERF_SAMPLE_PERIOD;	405	attr->sample_type \|= PERF_SAMPLE_PERIOD;
@@ -412,6 +419,8 @@ static void create_counter(int counter, int cpu, pid_t pid) · 13 unmodified lines
412	if (call_graph)	419	if (call_graph)
413	attr->sample_type \|= PERF_SAMPLE_CALLCHAIN;	420	attr->sample_type \|= PERF_SAMPLE_CALLCHAIN;
414		421
		422	if (raw_samples)
		423	attr->sample_type \|= PERF_SAMPLE_RAW;
415		424
416	attr->mmap = track;	425	attr->mmap = track;
417	attr->comm = track;	426	attr->comm = track;
@@ -426,6 +435,8 @@ try_again: · 8 unmodified lines
426		435
427	if (err == EPERM)	436	if (err == EPERM)
428	die("Permission error - are you root?\n");	437	die("Permission error - are you root?\n");
		438	else if (err == ENODEV && profile_cpu != -1)
		439	die("No such device - did you specify an out-of-range profile CPU?\n");
429		440
430	/*	441	/*
431	* If it's cycles then fall back to hrtimer	442	* If it's cycles then fall back to hrtimer
@@ -559,16 +570,22 @@ static int __cmd_record(int argc, const char **argv) · 127 unmodified lines
559	if (pid == -1)	570	if (pid == -1)
560	pid = getpid();	571	pid = getpid();
561		572
562	open_counters(-1, pid);	573	open_counters(profile_cpu, pid);
563	} else for (i = 0; i < nr_cpus; i++)	574	} else {
564	open_counters(i, target_pid);	575	if (profile_cpu != -1) {
		576	open_counters(profile_cpu, target_pid);
		577	} else {
		578	for (i = 0; i < nr_cpus; i++)
		579	open_counters(i, target_pid);
		580	}
		581	}
565		582
566	if (file_new)	583	if (file_new)
567	perf_header__write(header, output);	584	perf_header__write(header, output);
568		585
569	if (!system_wide) {	586	if (!system_wide) {
570	pid_synthesize_comm_event(pid, 0);	587	pid_t tgid = pid_synthesize_comm_event(pid, 0);
571	pid_synthesize_mmap_samples(pid);	588	pid_synthesize_mmap_samples(pid, tgid);
572	} else	589	} else
573	synthesize_all();	590	synthesize_all();
574		591
@@ -636,10 +653,14 @@ static const struct option options[] = { · 61 unmodified lines
636	"record events on existing pid"),	653	"record events on existing pid"),
637	OPT_INTEGER('r', "realtime", &realtime_prio,	654	OPT_INTEGER('r', "realtime", &realtime_prio,
638	"collect data with this RT SCHED_FIFO priority"),	655	"collect data with this RT SCHED_FIFO priority"),
		656	OPT_BOOLEAN('R', "raw-samples", &raw_samples,
		657	"collect raw sample records from all opened counters"),
639	OPT_BOOLEAN('a', "all-cpus", &system_wide,	658	OPT_BOOLEAN('a', "all-cpus", &system_wide,
640	"system-wide collection from all CPUs"),	659	"system-wide collection from all CPUs"),
641	OPT_BOOLEAN('A', "append", &append_file,	660	OPT_BOOLEAN('A', "append", &append_file,
642	"append to the output file to do incremental profiling"),	661	"append to the output file to do incremental profiling"),
		662	OPT_INTEGER('C', "profile_cpu", &profile_cpu,
		663	"CPU to profile on"),
643	OPT_BOOLEAN('f', "force", &force,	664	OPT_BOOLEAN('f', "force", &force,
644	"overwrite existing data file"),	665	"overwrite existing data file"),
645	OPT_LONG('c', "count", &default_interval,	666	OPT_LONG('c', "count", &default_interval,

tools/perf/builtin-report.c+7−5

 		more_data += sizeof(u64);
 	}
-	dprintf("%p [%p]: PERF_EVENT_SAMPLE (IP, %d): %d: %p period: %Ld\n",
+	dprintf("%p [%p]: PERF_EVENT_SAMPLE (IP, %d): %d/%d: %p period: %Ld\n",
 		(void *)(offset + head),
 		(void *)(long)(event->header.size),
 		event->header.misc,
-		event->ip.pid,
+		event->ip.pid, event->ip.tid,
 		(void *)(long)ip,
 		(long long)period);
 	if (show & show_mask) {
 		struct symbol *sym = resolve_symbol(thread, &map, &dso, &ip);
-		if (dso_list && dso && dso->name && !strlist__has_entry(dso_list, dso->name))
+		if (dso_list && (!dso || !dso->name ||
+				 !strlist__has_entry(dso_list, dso->name)))
 			return 0;
-		if (sym_list && sym && !strlist__has_entry(sym_list, sym->name))
+		if (sym_list && (!sym || !strlist__has_entry(sym_list, sym->name)))
 			return 0;
 		if (hist_entry__add(thread, map, dso, sym, ip, chain, level, period)) {
 	struct thread *thread = threads__findnew(event->mmap.pid);
 	struct map *map = map__new(&event->mmap);
-	dprintf("%p [%p]: PERF_EVENT_MMAP %d: [%p(%p) @ %p]: %s\n",
+	dprintf("%p [%p]: PERF_EVENT_MMAP %d/%d: [%p(%p) @ %p]: %s\n",
 		(void *)(offset + head),
 		(void *)(long)(event->header.size),
 		event->mmap.pid,
+		event->mmap.tid,
 		(void *)(long)event->mmap.start,
 		(void *)(long)event->mmap.len,
 		(void *)(long)event->mmap.pgoff,

tools/perf/util/parse-events.c+10−0

 				    struct perf_counter_attr *attr)
 {
 	const char *evt_name;
+	char *flags;
 	char sys_name[MAX_EVENT_LENGTH];
 	char id_buf[4];
 	int fd;
 	strncpy(sys_name, *strp, sys_length);
 	sys_name[sys_length] = '\0';
 	evt_name = evt_name + 1;
+	flags = strchr(evt_name, ':');
+	if (flags) {
+		*flags = '\0';
+		flags++;
+		if (!strncmp(flags, "record", strlen(flags)))
+			attr->sample_type |= PERF_SAMPLE_RAW;
+	}
 	evt_length = strlen(evt_name);
 	if (evt_length >= MAX_EVENT_LENGTH)
 		return 0;

tools/perf/util/symbol.c+2−15

 #include <gelf.h>
 #include <elf.h>
-#ifndef NO_DEMANGLE
-#include <bfd.h>
-#else
-static inline
-char *bfd_demangle(void __used *v, const char __used *c, int __used i)
-{
-	return NULL;
-}
-#endif
 const char *sym_hist_filter;
-#ifndef DMGL_PARAMS
-#define DMGL_PARAMS      (1 << 0)       /* Include function args */
-#define DMGL_ANSI        (1 << 1)       /* Include const, volatile, etc */
-#endif
 enum dso_origin {
 	DSO__ORIG_KERNEL = 0,
 	DSO__ORIG_JAVA_JIT,
 	}
 out:
 	free(name);
+	if (ret < 0 && strstr(self->name, " (deleted)") != NULL)
+		return 0;
 	return ret;
 }

tools/perf/util/symbol.h+24−0

@@ -7,6 +7,30 @@ · 6 unmodified lines
7	#include <linux/rbtree.h>	7	#include <linux/rbtree.h>
8	#include "module.h"	8	#include "module.h"
9		9
		10	#ifdef HAVE_CPLUS_DEMANGLE
		11	extern char cplus_demangle(const char , int);
		12
		13	static inline char bfd_demangle(void __used v, const char *c, int i)
		14	{
		15	return cplus_demangle(c, i);
		16	}
		17	#else
		18	#ifdef NO_DEMANGLE
		19	static inline char bfd_demangle(void __used v, const char __used *c,
		20	int __used i)
		21	{
		22	return NULL;
		23	}
		24	#else
		25	#include <bfd.h>
		26	#endif
		27	#endif
		28
		29	#ifndef DMGL_PARAMS
		30	#define DMGL_PARAMS (1 << 0) /* Include function args */
		31	#define DMGL_ANSI (1 << 1) /* Include const, volatile, etc */
		32	#endif
		33
10	struct symbol {	34	struct symbol {
11	struct rb_node rb_node;	35	struct rb_node rb_node;
12	u64 start;	36	u64 start;