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

Pull perf fixes from Ingo Molnar: "Mostly tooling fixes, but also some kernel side fixes: uncore PMU driver fix, user regs sampling fix and an instruction decoder fix that unbreaks PEBS precise sampling" * 'perf-urgent-for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/tip/tip: perf/x86/uncore/hsw-ep: Handle systems with only two SBOXes perf/x86_64: Improve user regs sampling perf: Move task_pt_regs sampling into arch code x86: Fix off-by-one in instruction decoder perf hists browser: Fix segfault when showing callchain perf callchain: Free callchains when hist entries are deleted perf hists: Fix children sort key behavior perf diff: Fix to sort by baseline field by default perf list: Fix --raw-dump option perf probe: Fix crash in dwarf_getcfi_elf perf probe: Fix to fall back to find probe point in symbols perf callchain: Append callchains only when requested perf ui/tui: Print backtrace symbols when segfault occurs perf report: Show progress bar for output resorting

Merge branch 'perf-urgent-for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/tip/tip
Pull perf fixes from Ingo Molnar: "Mostly tooling fixes, but also some kernel side fixes: uncore PMU driver fix, user regs sampling fix and an instruction decoder fix that unbreaks PEBS precise sampling" * 'perf-urgent-for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/tip/tip: perf/x86/uncore/hsw-ep: Handle systems with only two SBOXes perf/x86_64: Improve user regs sampling perf: Move task_pt_regs sampling into arch code x86: Fix off-by-one in instruction decoder perf hists browser: Fix segfault when showing callchain perf callchain: Free callchains when hist entries are deleted perf hists: Fix children sort key behavior perf diff: Fix to sort by baseline field by default perf list: Fix --raw-dump option perf probe: Fix crash in dwarf_getcfi_elf perf probe: Fix to fall back to find probe point in symbols perf callchain: Append callchains only when requested perf ui/tui: Print backtrace symbols when segfault occurs perf report: Show progress bar for output resorting
Linus Torvalds
2 parents 1e6c3e8f8f 5306c31c57
Showing 26 changed files Side-by-side Diff
arch/arm/kernel/perf_regs.c
arch/arm64/kernel/perf_regs.c
arch/x86/kernel/cpu/perf_event_intel_uncore.h
arch/x86/kernel/cpu/perf_event_intel_uncore_snbep.c
arch/x86/kernel/perf_regs.c
arch/x86/lib/insn.c
include/linux/perf_event.h
include/linux/perf_regs.h
kernel/events/core.c
tools/perf/builtin-annotate.c
tools/perf/builtin-diff.c
tools/perf/builtin-list.c
tools/perf/builtin-report.c
tools/perf/builtin-top.c
tools/perf/tests/hists_cumulate.c
tools/perf/tests/hists_filter.c
tools/perf/tests/hists_output.c
tools/perf/ui/browsers/hists.c
tools/perf/ui/hist.c
tools/perf/ui/tui/setup.c
@@ -28,4 +28,12 @@
 {
 	return PERF_SAMPLE_REGS_ABI_32;
 }
+
+void perf_get_regs_user(struct perf_regs *regs_user,
+			struct pt_regs *regs,
+			struct pt_regs *regs_user_copy)
+{
+	regs_user->regs = task_pt_regs(current);
+	regs_user->abi = perf_reg_abi(current);
+}
@@ -50,4 +50,12 @@
 	else
 		return PERF_SAMPLE_REGS_ABI_64;
 }
+
+void perf_get_regs_user(struct perf_regs *regs_user,
+			struct pt_regs *regs,
+			struct pt_regs *regs_user_copy)
+{
+	regs_user->regs = task_pt_regs(current);
+	regs_user->abi = perf_reg_abi(current);
+}
@@ -17,7 +17,7 @@
 #define UNCORE_PCI_DEV_TYPE(data)	((data >> 8) & 0xff)
 #define UNCORE_PCI_DEV_IDX(data)	(data & 0xff)
 #define UNCORE_EXTRA_PCI_DEV		0xff
-#define UNCORE_EXTRA_PCI_DEV_MAX	2
+#define UNCORE_EXTRA_PCI_DEV_MAX	3
  
 /* support up to 8 sockets */
 #define UNCORE_SOCKET_MAX		8
@@ -891,6 +891,7 @@
 enum {
 	SNBEP_PCI_QPI_PORT0_FILTER,
 	SNBEP_PCI_QPI_PORT1_FILTER,
+	HSWEP_PCI_PCU_3,
 };
  
 static int snbep_qpi_hw_config(struct intel_uncore_box *box, struct perf_event *event)
@@ -2026,6 +2027,17 @@
 {
 	if (hswep_uncore_cbox.num_boxes > boot_cpu_data.x86_max_cores)
 		hswep_uncore_cbox.num_boxes = boot_cpu_data.x86_max_cores;
+
+	/* Detect 6-8 core systems with only two SBOXes */
+	if (uncore_extra_pci_dev[0][HSWEP_PCI_PCU_3]) {
+		u32 capid4;
+
+		pci_read_config_dword(uncore_extra_pci_dev[0][HSWEP_PCI_PCU_3],
+				      0x94, &capid4);
+		if (((capid4 >> 6) & 0x3) == 0)
+			hswep_uncore_sbox.num_boxes = 2;
+	}
+
 	uncore_msr_uncores = hswep_msr_uncores;
 }
  
@@ -2286,6 +2298,11 @@
 		PCI_DEVICE(PCI_VENDOR_ID_INTEL, 0x2f96),
 		.driver_data = UNCORE_PCI_DEV_DATA(UNCORE_EXTRA_PCI_DEV,
 						   SNBEP_PCI_QPI_PORT1_FILTER),
+	},
+	{ /* PCU.3 (for Capability registers) */
+		PCI_DEVICE(PCI_VENDOR_ID_INTEL, 0x2fc0),
+		.driver_data = UNCORE_PCI_DEV_DATA(UNCORE_EXTRA_PCI_DEV,
+						   HSWEP_PCI_PCU_3),
 	},
 	{ /* end: all zeroes */ }
 };
@@ -78,6 +78,14 @@
 {
 	return PERF_SAMPLE_REGS_ABI_32;
 }
+
+void perf_get_regs_user(struct perf_regs *regs_user,
+			struct pt_regs *regs,
+			struct pt_regs *regs_user_copy)
+{
+	regs_user->regs = task_pt_regs(current);
+	regs_user->abi = perf_reg_abi(current);
+}
 #else /* CONFIG_X86_64 */
 #define REG_NOSUPPORT ((1ULL << PERF_REG_X86_DS) | \
 		       (1ULL << PERF_REG_X86_ES) | \
@@ -101,6 +109,88 @@
 		return PERF_SAMPLE_REGS_ABI_32;
 	else
 		return PERF_SAMPLE_REGS_ABI_64;
+}
+
+void perf_get_regs_user(struct perf_regs *regs_user,
+			struct pt_regs *regs,
+			struct pt_regs *regs_user_copy)
+{
+	struct pt_regs *user_regs = task_pt_regs(current);
+
+	/*
+	 * If we're in an NMI that interrupted task_pt_regs setup, then
+	 * we can't sample user regs at all.  This check isn't really
+	 * sufficient, though, as we could be in an NMI inside an interrupt
+	 * that happened during task_pt_regs setup.
+	 */
+	if (regs->sp > (unsigned long)&user_regs->r11 &&
+	    regs->sp <= (unsigned long)(user_regs + 1)) {
+		regs_user->abi = PERF_SAMPLE_REGS_ABI_NONE;
+		regs_user->regs = NULL;
+		return;
+	}
+
+	/*
+	 * RIP, flags, and the argument registers are usually saved.
+	 * orig_ax is probably okay, too.
+	 */
+	regs_user_copy->ip = user_regs->ip;
+	regs_user_copy->cx = user_regs->cx;
+	regs_user_copy->dx = user_regs->dx;
+	regs_user_copy->si = user_regs->si;
+	regs_user_copy->di = user_regs->di;
+	regs_user_copy->r8 = user_regs->r8;
+	regs_user_copy->r9 = user_regs->r9;
+	regs_user_copy->r10 = user_regs->r10;
+	regs_user_copy->r11 = user_regs->r11;
+	regs_user_copy->orig_ax = user_regs->orig_ax;
+	regs_user_copy->flags = user_regs->flags;
+
+	/*
+	 * Don't even try to report the "rest" regs.
+	 */
+	regs_user_copy->bx = -1;
+	regs_user_copy->bp = -1;
+	regs_user_copy->r12 = -1;
+	regs_user_copy->r13 = -1;
+	regs_user_copy->r14 = -1;
+	regs_user_copy->r15 = -1;
+
+	/*
+	 * For this to be at all useful, we need a reasonable guess for
+	 * sp and the ABI.  Be careful: we're in NMI context, and we're
+	 * considering current to be the current task, so we should
+	 * be careful not to look at any other percpu variables that might
+	 * change during context switches.
+	 */
+	if (IS_ENABLED(CONFIG_IA32_EMULATION) &&
+	    task_thread_info(current)->status & TS_COMPAT) {
+		/* Easy case: we're in a compat syscall. */
+		regs_user->abi = PERF_SAMPLE_REGS_ABI_32;
+		regs_user_copy->sp = user_regs->sp;
+		regs_user_copy->cs = user_regs->cs;
+		regs_user_copy->ss = user_regs->ss;
+	} else if (user_regs->orig_ax != -1) {
+		/*
+		 * We're probably in a 64-bit syscall.
+		 * Warning: this code is severely racy.  At least it's better
+		 * than just blindly copying user_regs.
+		 */
+		regs_user->abi = PERF_SAMPLE_REGS_ABI_64;
+		regs_user_copy->sp = this_cpu_read(old_rsp);
+		regs_user_copy->cs = __USER_CS;
+		regs_user_copy->ss = __USER_DS;
+		regs_user_copy->cx = -1;  /* usually contains garbage */
+	} else {
+		/* We're probably in an interrupt or exception. */
+		regs_user->abi = user_64bit_mode(user_regs) ?
+			PERF_SAMPLE_REGS_ABI_64 : PERF_SAMPLE_REGS_ABI_32;
+		regs_user_copy->sp = user_regs->sp;
+		regs_user_copy->cs = user_regs->cs;
+		regs_user_copy->ss = user_regs->ss;
+	}
+
+	regs_user->regs = regs_user_copy;
 }
 #endif /* CONFIG_X86_32 */
@@ -28,7 +28,7 @@
  
 /* Verify next sizeof(t) bytes can be on the same instruction */
 #define validate_next(t, insn, n)	\
-	((insn)->next_byte + sizeof(t) + n < (insn)->end_kaddr)
+	((insn)->next_byte + sizeof(t) + n <= (insn)->end_kaddr)
  
 #define __get_next(t, insn)	\
 	({ t r = *(t*)insn->next_byte; insn->next_byte += sizeof(t); r; })
@@ -79,11 +79,6 @@
 	struct perf_branch_entry	entries[0];
 };
  
-struct perf_regs {
-	__u64		abi;
-	struct pt_regs	*regs;
-};
-
 struct task_struct;
  
 /*
  
@@ -610,7 +605,14 @@
 		u32	reserved;
 	}				cpu_entry;
 	struct perf_callchain_entry	*callchain;
+
+	/*
+	 * regs_user may point to task_pt_regs or to regs_user_copy, depending
+	 * on arch details.
+	 */
 	struct perf_regs		regs_user;
+	struct pt_regs			regs_user_copy;
+
 	struct perf_regs		regs_intr;
 	u64				stack_user_size;
 } ____cacheline_aligned;
 #ifndef _LINUX_PERF_REGS_H
 #define _LINUX_PERF_REGS_H
  
+struct perf_regs {
+	__u64		abi;
+	struct pt_regs	*regs;
+};
+
 #ifdef CONFIG_HAVE_PERF_REGS
 #include <asm/perf_regs.h>
 u64 perf_reg_value(struct pt_regs *regs, int idx);
 int perf_reg_validate(u64 mask);
 u64 perf_reg_abi(struct task_struct *task);
+void perf_get_regs_user(struct perf_regs *regs_user,
+			struct pt_regs *regs,
+			struct pt_regs *regs_user_copy);
 #else
 static inline u64 perf_reg_value(struct pt_regs *regs, int idx)
 {
@@ -20,6 +28,14 @@
 static inline u64 perf_reg_abi(struct task_struct *task)
 {
 	return PERF_SAMPLE_REGS_ABI_NONE;
+}
+
+static inline void perf_get_regs_user(struct perf_regs *regs_user,
+				      struct pt_regs *regs,
+				      struct pt_regs *regs_user_copy)
+{
+	regs_user->regs = task_pt_regs(current);
+	regs_user->abi = perf_reg_abi(current);
 }
 #endif /* CONFIG_HAVE_PERF_REGS */
 #endif /* _LINUX_PERF_REGS_H */
@@ -4461,18 +4461,14 @@
 }
  
 static void perf_sample_regs_user(struct perf_regs *regs_user,
-				  struct pt_regs *regs)
+				  struct pt_regs *regs,
+				  struct pt_regs *regs_user_copy)
 {
-	if (!user_mode(regs)) {
-		if (current->mm)
-			regs = task_pt_regs(current);
-		else
-			regs = NULL;
-	}
-
-	if (regs) {
-		regs_user->abi  = perf_reg_abi(current);
+	if (user_mode(regs)) {
+		regs_user->abi = perf_reg_abi(current);
 		regs_user->regs = regs;
+	} else if (current->mm) {
+		perf_get_regs_user(regs_user, regs, regs_user_copy);
 	} else {
 		regs_user->abi = PERF_SAMPLE_REGS_ABI_NONE;
 		regs_user->regs = NULL;
@@ -4951,7 +4947,8 @@
 	}
  
 	if (sample_type & (PERF_SAMPLE_REGS_USER | PERF_SAMPLE_STACK_USER))
-		perf_sample_regs_user(&data->regs_user, regs);
+		perf_sample_regs_user(&data->regs_user, regs,
+				      &data->regs_user_copy);
  
 	if (sample_type & PERF_SAMPLE_REGS_USER) {
 		/* regs dump ABI info */
@@ -232,7 +232,7 @@
 		if (nr_samples > 0) {
 			total_nr_samples += nr_samples;
 			hists__collapse_resort(hists, NULL);
-			hists__output_resort(hists);
+			hists__output_resort(hists, NULL);
  
 			if (symbol_conf.event_group &&
 			    !perf_evsel__is_group_leader(pos))
@@ -545,6 +545,42 @@
 	return __hist_entry__cmp_compute(p_left, p_right, c);
 }
  
+static int64_t
+hist_entry__cmp_nop(struct hist_entry *left __maybe_unused,
+		    struct hist_entry *right __maybe_unused)
+{
+	return 0;
+}
+
+static int64_t
+hist_entry__cmp_baseline(struct hist_entry *left, struct hist_entry *right)
+{
+	if (sort_compute)
+		return 0;
+
+	if (left->stat.period == right->stat.period)
+		return 0;
+	return left->stat.period > right->stat.period ? 1 : -1;
+}
+
+static int64_t
+hist_entry__cmp_delta(struct hist_entry *left, struct hist_entry *right)
+{
+	return hist_entry__cmp_compute(right, left, COMPUTE_DELTA);
+}
+
+static int64_t
+hist_entry__cmp_ratio(struct hist_entry *left, struct hist_entry *right)
+{
+	return hist_entry__cmp_compute(right, left, COMPUTE_RATIO);
+}
+
+static int64_t
+hist_entry__cmp_wdiff(struct hist_entry *left, struct hist_entry *right)
+{
+	return hist_entry__cmp_compute(right, left, COMPUTE_WEIGHTED_DIFF);
+}
+
 static void insert_hist_entry_by_compute(struct rb_root *root,
 					 struct hist_entry *he,
 					 int c)
@@ -605,7 +641,7 @@
 		hists__precompute(hists);
 		hists__compute_resort(hists);
 	} else {
-		hists__output_resort(hists);
+		hists__output_resort(hists, NULL);
 	}
  
 	hists__fprintf(hists, true, 0, 0, 0, stdout);
  
  
  
  
  
  
@@ -1038,27 +1074,35 @@
 	fmt->header = hpp__header;
 	fmt->width  = hpp__width;
 	fmt->entry  = hpp__entry_global;
+	fmt->cmp    = hist_entry__cmp_nop;
+	fmt->collapse = hist_entry__cmp_nop;
  
 	/* TODO more colors */
 	switch (idx) {
 	case PERF_HPP_DIFF__BASELINE:
 		fmt->color = hpp__color_baseline;
+		fmt->sort  = hist_entry__cmp_baseline;
 		break;
 	case PERF_HPP_DIFF__DELTA:
 		fmt->color = hpp__color_delta;
+		fmt->sort  = hist_entry__cmp_delta;
 		break;
 	case PERF_HPP_DIFF__RATIO:
 		fmt->color = hpp__color_ratio;
+		fmt->sort  = hist_entry__cmp_ratio;
 		break;
 	case PERF_HPP_DIFF__WEIGHTED_DIFF:
 		fmt->color = hpp__color_wdiff;
+		fmt->sort  = hist_entry__cmp_wdiff;
 		break;
 	default:
+		fmt->sort  = hist_entry__cmp_nop;
 		break;
 	}
  
 	init_header(d, dfmt);
 	perf_hpp__column_register(fmt);
+	perf_hpp__register_sort_field(fmt);
 }
  
 static void ui_init(void)
@@ -19,7 +19,9 @@
 int cmd_list(int argc, const char **argv, const char *prefix __maybe_unused)
 {
 	int i;
-	const struct option list_options[] = {
+	bool raw_dump = false;
+	struct option list_options[] = {
+		OPT_BOOLEAN(0, "raw-dump", &raw_dump, "Dump raw events"),
 		OPT_END()
 	};
 	const char * const list_usage[] = {
  
@@ -27,11 +29,18 @@
 		NULL
 	};
  
+	set_option_flag(list_options, 0, "raw-dump", PARSE_OPT_HIDDEN);
+
 	argc = parse_options(argc, argv, list_options, list_usage,
 			     PARSE_OPT_STOP_AT_NON_OPTION);
  
 	setup_pager();
  
+	if (raw_dump) {
+		print_events(NULL, true);
+		return 0;
+	}
+
 	if (argc == 0) {
 		print_events(NULL, false);
 		return 0;
@@ -53,8 +62,6 @@
 			print_hwcache_events(NULL, false);
 		else if (strcmp(argv[i], "pmu") == 0)
 			print_pmu_events(NULL, false);
-		else if (strcmp(argv[i], "--raw-dump") == 0)
-			print_events(NULL, true);
 		else {
 			char *sep = strchr(argv[i], ':'), *s;
 			int sep_idx;
@@ -457,6 +457,19 @@
 	ui_progress__finish();
 }
  
+static void report__output_resort(struct report *rep)
+{
+	struct ui_progress prog;
+	struct perf_evsel *pos;
+
+	ui_progress__init(&prog, rep->nr_entries, "Sorting events for output...");
+
+	evlist__for_each(rep->session->evlist, pos)
+		hists__output_resort(evsel__hists(pos), &prog);
+
+	ui_progress__finish();
+}
+
 static int __cmd_report(struct report *rep)
 {
 	int ret;
  
@@ -505,13 +518,20 @@
 	if (session_done())
 		return 0;
  
+	/*
+	 * recalculate number of entries after collapsing since it
+	 * might be changed during the collapse phase.
+	 */
+	rep->nr_entries = 0;
+	evlist__for_each(session->evlist, pos)
+		rep->nr_entries += evsel__hists(pos)->nr_entries;
+
 	if (rep->nr_entries == 0) {
 		ui__error("The %s file has no samples!\n", file->path);
 		return 0;
 	}
  
-	evlist__for_each(session->evlist, pos)
-		hists__output_resort(evsel__hists(pos));
+	report__output_resort(rep);
  
 	return report__browse_hists(rep);
 }
@@ -285,7 +285,7 @@
 	}
  
 	hists__collapse_resort(hists, NULL);
-	hists__output_resort(hists);
+	hists__output_resort(hists, NULL);
  
 	hists__output_recalc_col_len(hists, top->print_entries - printed);
 	putchar('\n');
@@ -554,7 +554,7 @@
 	}
  
 	hists__collapse_resort(hists, NULL);
-	hists__output_resort(hists);
+	hists__output_resort(hists, NULL);
 }
  
 static void *display_thread_tui(void *arg)
@@ -187,7 +187,7 @@
 	 * function since TEST_ASSERT_VAL() returns in case of failure.
 	 */
 	hists__collapse_resort(hists, NULL);
-	hists__output_resort(hists);
+	hists__output_resort(hists, NULL);
  
 	if (verbose > 2) {
 		pr_info("use callchain: %d, cumulate callchain: %d\n",
  
  
@@ -454,12 +454,12 @@
 	 *   30.00%    10.00%     perf  perf           [.] cmd_record
 	 *   20.00%     0.00%     bash  libc           [.] malloc
 	 *   10.00%    10.00%     bash  [kernel]       [k] page_fault
-	 *   10.00%    10.00%     perf  [kernel]       [k] schedule
-	 *   10.00%     0.00%     perf  [kernel]       [k] sys_perf_event_open
+	 *   10.00%    10.00%     bash  bash           [.] xmalloc
 	 *   10.00%    10.00%     perf  [kernel]       [k] page_fault
-	 *   10.00%    10.00%     perf  libc           [.] free
 	 *   10.00%    10.00%     perf  libc           [.] malloc
-	 *   10.00%    10.00%     bash  bash           [.] xmalloc
+	 *   10.00%    10.00%     perf  [kernel]       [k] schedule
+	 *   10.00%    10.00%     perf  libc           [.] free
+	 *   10.00%     0.00%     perf  [kernel]       [k] sys_perf_event_open
 	 */
 	struct result expected[] = {
 		{ 7000, 2000, "perf", "perf",     "main" },
  
  
@@ -468,12 +468,12 @@
 		{ 3000, 1000, "perf", "perf",     "cmd_record" },
 		{ 2000,    0, "bash", "libc",     "malloc" },
 		{ 1000, 1000, "bash", "[kernel]", "page_fault" },
-		{ 1000, 1000, "perf", "[kernel]", "schedule" },
-		{ 1000,    0, "perf", "[kernel]", "sys_perf_event_open" },
+		{ 1000, 1000, "bash", "bash",     "xmalloc" },
 		{ 1000, 1000, "perf", "[kernel]", "page_fault" },
+		{ 1000, 1000, "perf", "[kernel]", "schedule" },
 		{ 1000, 1000, "perf", "libc",     "free" },
 		{ 1000, 1000, "perf", "libc",     "malloc" },
-		{ 1000, 1000, "bash", "bash",     "xmalloc" },
+		{ 1000,    0, "perf", "[kernel]", "sys_perf_event_open" },
 	};
  
 	symbol_conf.use_callchain = false;
  
@@ -537,10 +537,13 @@
 	 *                  malloc
 	 *                  main
 	 *
-	 *   10.00%    10.00%     perf  [kernel]       [k] schedule
+	 *   10.00%    10.00%     bash  bash           [.] xmalloc
 	 *              |
-	 *              --- schedule
-	 *                  run_command
+	 *              --- xmalloc
+	 *                  malloc
+	 *                  xmalloc     <--- NOTE: there's a cycle
+	 *                  malloc
+	 *                  xmalloc
 	 *                  main
 	 *
 	 *   10.00%     0.00%     perf  [kernel]       [k] sys_perf_event_open
@@ -556,6 +559,12 @@
 	 *                  run_command
 	 *                  main
 	 *
+	 *   10.00%    10.00%     perf  [kernel]       [k] schedule
+	 *              |
+	 *              --- schedule
+	 *                  run_command
+	 *                  main
+	 *
 	 *   10.00%    10.00%     perf  libc           [.] free
 	 *              |
 	 *              --- free
@@ -570,15 +579,6 @@
 	 *                  run_command
 	 *                  main
 	 *
-	 *   10.00%    10.00%     bash  bash           [.] xmalloc
-	 *              |
-	 *              --- xmalloc
-	 *                  malloc
-	 *                  xmalloc     <--- NOTE: there's a cycle
-	 *                  malloc
-	 *                  xmalloc
-	 *                  main
-	 *
 	 */
 	struct result expected[] = {
 		{ 7000, 2000, "perf", "perf",     "main" },
  
  
@@ -587,12 +587,12 @@
 		{ 3000, 1000, "perf", "perf",     "cmd_record" },
 		{ 2000,    0, "bash", "libc",     "malloc" },
 		{ 1000, 1000, "bash", "[kernel]", "page_fault" },
-		{ 1000, 1000, "perf", "[kernel]", "schedule" },
+		{ 1000, 1000, "bash", "bash",     "xmalloc" },
 		{ 1000,    0, "perf", "[kernel]", "sys_perf_event_open" },
 		{ 1000, 1000, "perf", "[kernel]", "page_fault" },
+		{ 1000, 1000, "perf", "[kernel]", "schedule" },
 		{ 1000, 1000, "perf", "libc",     "free" },
 		{ 1000, 1000, "perf", "libc",     "malloc" },
-		{ 1000, 1000, "bash", "bash",     "xmalloc" },
 	};
 	struct callchain_result expected_callchain[] = {
 		{
@@ -622,9 +622,12 @@
 				{ "bash",     "main" }, },
 		},
 		{
-			3, {	{ "[kernel]", "schedule" },
-				{ "perf",     "run_command" },
-				{ "perf",     "main" }, },
+			6, {	{ "bash",     "xmalloc" },
+				{ "libc",     "malloc" },
+				{ "bash",     "xmalloc" },
+				{ "libc",     "malloc" },
+				{ "bash",     "xmalloc" },
+				{ "bash",     "main" }, },
 		},
 		{
 			3, {	{ "[kernel]", "sys_perf_event_open" },
@@ -638,6 +641,11 @@
 				{ "perf",     "main" }, },
 		},
 		{
+			3, {	{ "[kernel]", "schedule" },
+				{ "perf",     "run_command" },
+				{ "perf",     "main" }, },
+		},
+		{
 			4, {	{ "libc",     "free" },
 				{ "perf",     "cmd_record" },
 				{ "perf",     "run_command" },
@@ -648,14 +656,6 @@
 				{ "perf",     "cmd_record" },
 				{ "perf",     "run_command" },
 				{ "perf",     "main" }, },
-		},
-		{
-			6, {	{ "bash",     "xmalloc" },
-				{ "libc",     "malloc" },
-				{ "bash",     "xmalloc" },
-				{ "libc",     "malloc" },
-				{ "bash",     "xmalloc" },
-				{ "bash",     "main" }, },
 		},
 	};
  
@@ -138,7 +138,7 @@
 		struct hists *hists = evsel__hists(evsel);
  
 		hists__collapse_resort(hists, NULL);
-		hists__output_resort(hists);
+		hists__output_resort(hists, NULL);
  
 		if (verbose > 2) {
 			pr_info("Normal histogram\n");
@@ -152,7 +152,7 @@
 		goto out;
  
 	hists__collapse_resort(hists, NULL);
-	hists__output_resort(hists);
+	hists__output_resort(hists, NULL);
  
 	if (verbose > 2) {
 		pr_info("[fields = %s, sort = %s]\n", field_order, sort_order);
@@ -252,7 +252,7 @@
 		goto out;
  
 	hists__collapse_resort(hists, NULL);
-	hists__output_resort(hists);
+	hists__output_resort(hists, NULL);
  
 	if (verbose > 2) {
 		pr_info("[fields = %s, sort = %s]\n", field_order, sort_order);
@@ -306,7 +306,7 @@
 		goto out;
  
 	hists__collapse_resort(hists, NULL);
-	hists__output_resort(hists);
+	hists__output_resort(hists, NULL);
  
 	if (verbose > 2) {
 		pr_info("[fields = %s, sort = %s]\n", field_order, sort_order);
@@ -384,7 +384,7 @@
 		goto out;
  
 	hists__collapse_resort(hists, NULL);
-	hists__output_resort(hists);
+	hists__output_resort(hists, NULL);
  
 	if (verbose > 2) {
 		pr_info("[fields = %s, sort = %s]\n", field_order, sort_order);
@@ -487,7 +487,7 @@
 		goto out;
  
 	hists__collapse_resort(hists, NULL);
-	hists__output_resort(hists);
+	hists__output_resort(hists, NULL);
  
 	if (verbose > 2) {
 		pr_info("[fields = %s, sort = %s]\n", field_order, sort_order);
@@ -550,7 +550,7 @@
 	bool need_percent;
  
 	node = rb_first(root);
-	need_percent = !!rb_next(node);
+	need_percent = node && rb_next(node);
  
 	while (node) {
 		struct callchain_node *child = rb_entry(node, struct callchain_node, rb_node);
@@ -204,6 +204,9 @@
 		if (ret)
 			return ret;
  
+		if (a->thread != b->thread || !symbol_conf.use_callchain)
+			return 0;
+
 		ret = b->callchain->max_depth - a->callchain->max_depth;
 	}
 	return ret;
 #include <signal.h>
 #include <stdbool.h>
+#ifdef HAVE_BACKTRACE_SUPPORT
+#include <execinfo.h>
+#endif
  
 #include "../../util/cache.h"
 #include "../../util/debug.h"
@@ -88,6 +91,25 @@
 	return SLkp_getkey();
 }
  
+#ifdef HAVE_BACKTRACE_SUPPORT
+static void ui__signal_backtrace(int sig)
+{
+	void *stackdump[32];
+	size_t size;
+
+	ui__exit(false);
+	psignal(sig, "perf");
+
+	printf("-------- backtrace --------\n");
+	size = backtrace(stackdump, ARRAY_SIZE(stackdump));
+	backtrace_symbols_fd(stackdump, size, STDOUT_FILENO);
+
+	exit(0);
+}
+#else
+# define ui__signal_backtrace  ui__signal
+#endif
+
 static void ui__signal(int sig)
 {
 	ui__exit(false);
@@ -122,8 +144,8 @@
 	ui_browser__init();
 	tui_progress__init();
  
-	signal(SIGSEGV, ui__signal);
-	signal(SIGFPE, ui__signal);
+	signal(SIGSEGV, ui__signal_backtrace);
+	signal(SIGFPE, ui__signal_backtrace);
 	signal(SIGINT, ui__signal);
 	signal(SIGQUIT, ui__signal);
 	signal(SIGTERM, ui__signal);
@@ -841,4 +841,34 @@
  
 	return bf;
 }
+
+static void free_callchain_node(struct callchain_node *node)
+{
+	struct callchain_list *list, *tmp;
+	struct callchain_node *child;
+	struct rb_node *n;
+
+	list_for_each_entry_safe(list, tmp, &node->val, list) {
+		list_del(&list->list);
+		free(list);
+	}
+
+	n = rb_first(&node->rb_root_in);
+	while (n) {
+		child = container_of(n, struct callchain_node, rb_node_in);
+		n = rb_next(n);
+		rb_erase(&child->rb_node_in, &node->rb_root_in);
+
+		free_callchain_node(child);
+		free(child);
+	}
+}
+
+void free_callchain(struct callchain_root *root)
+{
+	if (!symbol_conf.use_callchain)
+		return;
+
+	free_callchain_node(&root->node);
+}
@@ -198,5 +198,7 @@
 char *callchain_list__sym_name(struct callchain_list *cl,
 			       char *bf, size_t bfsize, bool show_dso);
  
+void free_callchain(struct callchain_root *root);
+
 #endif	/* __PERF_CALLCHAIN_H */
@@ -6,6 +6,7 @@
 #include "evlist.h"
 #include "evsel.h"
 #include "annotate.h"
+#include "ui/progress.h"
 #include <math.h>
  
 static bool hists__filter_entry_by_dso(struct hists *hists,
@@ -303,7 +304,7 @@
 	size_t callchain_size = 0;
 	struct hist_entry *he;
  
-	if (symbol_conf.use_callchain || symbol_conf.cumulate_callchain)
+	if (symbol_conf.use_callchain)
 		callchain_size = sizeof(struct callchain_root);
  
 	he = zalloc(sizeof(*he) + callchain_size);
@@ -736,7 +737,7 @@
 	iter->he = he;
 	he_cache[iter->curr++] = he;
  
-	callchain_append(he->callchain, &callchain_cursor, sample->period);
+	hist_entry__append_callchain(he, sample);
  
 	/*
 	 * We need to re-initialize the cursor since callchain_append()
@@ -809,7 +810,8 @@
 	iter->he = he;
 	he_cache[iter->curr++] = he;
  
-	callchain_append(he->callchain, &cursor, sample->period);
+	if (symbol_conf.use_callchain)
+		callchain_append(he->callchain, &cursor, sample->period);
 	return 0;
 }
  
@@ -945,6 +947,7 @@
 	zfree(&he->mem_info);
 	zfree(&he->stat_acc);
 	free_srcline(he->srcline);
+	free_callchain(he->callchain);
 	free(he);
 }
  
@@ -987,6 +990,7 @@
 		else
 			p = &(*p)->rb_right;
 	}
+	hists->nr_entries++;
  
 	rb_link_node(&he->rb_node_in, parent, p);
 	rb_insert_color(&he->rb_node_in, root);
  
@@ -1024,7 +1028,10 @@
 	if (!sort__need_collapse)
 		return;
  
+	hists->nr_entries = 0;
+
 	root = hists__get_rotate_entries_in(hists);
+
 	next = rb_first(root);
  
 	while (next) {
@@ -1119,7 +1126,7 @@
 	rb_insert_color(&he->rb_node, entries);
 }
  
-void hists__output_resort(struct hists *hists)
+void hists__output_resort(struct hists *hists, struct ui_progress *prog)
 {
 	struct rb_root *root;
 	struct rb_node *next;
@@ -1148,6 +1155,9 @@
  
 		if (!n->filtered)
 			hists__calc_col_len(hists, n);
+
+		if (prog)
+			ui_progress__update(prog, 1);
 	}
 }
  
@@ -121,7 +121,7 @@
 			      struct hists *hists);
 void hist_entry__free(struct hist_entry *);
  
-void hists__output_resort(struct hists *hists);
+void hists__output_resort(struct hists *hists, struct ui_progress *prog);
 void hists__collapse_resort(struct hists *hists, struct ui_progress *prog);
  
 void hists__decay_entries(struct hists *hists, bool zap_user, bool zap_kernel);
@@ -495,9 +495,11 @@
 	}
  
 	if (ntevs == 0)	{	/* No error but failed to find probe point. */
-		pr_warning("Probe point '%s' not found.\n",
+		pr_warning("Probe point '%s' not found in debuginfo.\n",
 			   synthesize_perf_probe_point(&pev->point));
-		return -ENOENT;
+		if (need_dwarf)
+			return -ENOENT;
+		return 0;
 	}
 	/* Error path : ntevs < 0 */
 	pr_debug("An error occurred in debuginfo analysis (%d).\n", ntevs);
@@ -989,8 +989,24 @@
 	int ret = 0;
  
 #if _ELFUTILS_PREREQ(0, 142)
+	Elf *elf;
+	GElf_Ehdr ehdr;
+	GElf_Shdr shdr;
+
 	/* Get the call frame information from this dwarf */
-	pf->cfi = dwarf_getcfi_elf(dwarf_getelf(dbg->dbg));
+	elf = dwarf_getelf(dbg->dbg);
+	if (elf == NULL)
+		return -EINVAL;
+
+	if (gelf_getehdr(elf, &ehdr) == NULL)
+		return -EINVAL;
+
+	if (elf_section_by_name(elf, &ehdr, &shdr, ".eh_frame", NULL) &&
+	    shdr.sh_type == SHT_PROGBITS) {
+		pf->cfi = dwarf_getcfi_elf(elf);
+	} else {
+		pf->cfi = dwarf_getcfi(dbg->dbg);
+	}
 #endif
  
 	off = 0;
...	...	@@ -28,4 +28,12 @@
28	28	{
29	29	return PERF_SAMPLE_REGS_ABI_32;
30	30	}
	31	+
	32	+void perf_get_regs_user(struct perf_regs *regs_user,
	33	+ struct pt_regs *regs,
	34	+ struct pt_regs *regs_user_copy)
	35	+{
	36	+ regs_user->regs = task_pt_regs(current);
	37	+ regs_user->abi = perf_reg_abi(current);
	38	+}
...	...	@@ -50,4 +50,12 @@
50	50	else
51	51	return PERF_SAMPLE_REGS_ABI_64;
52	52	}
	53	+
	54	+void perf_get_regs_user(struct perf_regs *regs_user,
	55	+ struct pt_regs *regs,
	56	+ struct pt_regs *regs_user_copy)
	57	+{
	58	+ regs_user->regs = task_pt_regs(current);
	59	+ regs_user->abi = perf_reg_abi(current);
	60	+}
...	...	@@ -17,7 +17,7 @@
17	17	#define UNCORE_PCI_DEV_TYPE(data) ((data >> 8) & 0xff)
18	18	#define UNCORE_PCI_DEV_IDX(data) (data & 0xff)
19	19	#define UNCORE_EXTRA_PCI_DEV 0xff
20		-#define UNCORE_EXTRA_PCI_DEV_MAX 2
	20	+#define UNCORE_EXTRA_PCI_DEV_MAX 3
21	21
22	22	/* support up to 8 sockets */
23	23	#define UNCORE_SOCKET_MAX 8
...	...	@@ -891,6 +891,7 @@
891	891	enum {
892	892	SNBEP_PCI_QPI_PORT0_FILTER,
893	893	SNBEP_PCI_QPI_PORT1_FILTER,
	894	+ HSWEP_PCI_PCU_3,
894	895	};
895	896
896	897	static int snbep_qpi_hw_config(struct intel_uncore_box box, struct perf_event event)
...	...	@@ -2026,6 +2027,17 @@
2026	2027	{
2027	2028	if (hswep_uncore_cbox.num_boxes > boot_cpu_data.x86_max_cores)
2028	2029	hswep_uncore_cbox.num_boxes = boot_cpu_data.x86_max_cores;
	2030	+
	2031	+ /* Detect 6-8 core systems with only two SBOXes */
	2032	+ if (uncore_extra_pci_dev[0][HSWEP_PCI_PCU_3]) {
	2033	+ u32 capid4;
	2034	+
	2035	+ pci_read_config_dword(uncore_extra_pci_dev[0][HSWEP_PCI_PCU_3],
	2036	+ 0x94, &capid4);
	2037	+ if (((capid4 >> 6) & 0x3) == 0)
	2038	+ hswep_uncore_sbox.num_boxes = 2;
	2039	+ }
	2040	+
2029	2041	uncore_msr_uncores = hswep_msr_uncores;
2030	2042	}
2031	2043
...	...	@@ -2286,6 +2298,11 @@
2286	2298	PCI_DEVICE(PCI_VENDOR_ID_INTEL, 0x2f96),
2287	2299	.driver_data = UNCORE_PCI_DEV_DATA(UNCORE_EXTRA_PCI_DEV,
2288	2300	SNBEP_PCI_QPI_PORT1_FILTER),
	2301	+ },
	2302	+ { /* PCU.3 (for Capability registers) */
	2303	+ PCI_DEVICE(PCI_VENDOR_ID_INTEL, 0x2fc0),
	2304	+ .driver_data = UNCORE_PCI_DEV_DATA(UNCORE_EXTRA_PCI_DEV,
	2305	+ HSWEP_PCI_PCU_3),
2289	2306	},
2290	2307	{ /* end: all zeroes */ }
2291	2308	};
...	...	@@ -78,6 +78,14 @@
78	78	{
79	79	return PERF_SAMPLE_REGS_ABI_32;
80	80	}
	81	+
	82	+void perf_get_regs_user(struct perf_regs *regs_user,
	83	+ struct pt_regs *regs,
	84	+ struct pt_regs *regs_user_copy)
	85	+{
	86	+ regs_user->regs = task_pt_regs(current);
	87	+ regs_user->abi = perf_reg_abi(current);
	88	+}
81	89	#else /* CONFIG_X86_64 */
82	90	#define REG_NOSUPPORT ((1ULL << PERF_REG_X86_DS) \| \
83	91	(1ULL << PERF_REG_X86_ES) \| \
...	...	@@ -101,6 +109,88 @@
101	109	return PERF_SAMPLE_REGS_ABI_32;
102	110	else
103	111	return PERF_SAMPLE_REGS_ABI_64;
	112	+}
	113	+
	114	+void perf_get_regs_user(struct perf_regs *regs_user,
	115	+ struct pt_regs *regs,
	116	+ struct pt_regs *regs_user_copy)
	117	+{
	118	+ struct pt_regs *user_regs = task_pt_regs(current);
	119	+
	120	+ /*
	121	+ * If we're in an NMI that interrupted task_pt_regs setup, then
	122	+ * we can't sample user regs at all. This check isn't really
	123	+ * sufficient, though, as we could be in an NMI inside an interrupt
	124	+ * that happened during task_pt_regs setup.
	125	+ */
	126	+ if (regs->sp > (unsigned long)&user_regs->r11 &&
	127	+ regs->sp <= (unsigned long)(user_regs + 1)) {
	128	+ regs_user->abi = PERF_SAMPLE_REGS_ABI_NONE;
	129	+ regs_user->regs = NULL;
	130	+ return;
	131	+ }
	132	+
	133	+ /*
	134	+ * RIP, flags, and the argument registers are usually saved.
	135	+ * orig_ax is probably okay, too.
	136	+ */
	137	+ regs_user_copy->ip = user_regs->ip;
	138	+ regs_user_copy->cx = user_regs->cx;
	139	+ regs_user_copy->dx = user_regs->dx;
	140	+ regs_user_copy->si = user_regs->si;
	141	+ regs_user_copy->di = user_regs->di;
	142	+ regs_user_copy->r8 = user_regs->r8;
	143	+ regs_user_copy->r9 = user_regs->r9;
	144	+ regs_user_copy->r10 = user_regs->r10;
	145	+ regs_user_copy->r11 = user_regs->r11;
	146	+ regs_user_copy->orig_ax = user_regs->orig_ax;
	147	+ regs_user_copy->flags = user_regs->flags;
	148	+
	149	+ /*
	150	+ * Don't even try to report the "rest" regs.
	151	+ */
	152	+ regs_user_copy->bx = -1;
	153	+ regs_user_copy->bp = -1;
	154	+ regs_user_copy->r12 = -1;
	155	+ regs_user_copy->r13 = -1;
	156	+ regs_user_copy->r14 = -1;
	157	+ regs_user_copy->r15 = -1;
	158	+
	159	+ /*
	160	+ * For this to be at all useful, we need a reasonable guess for
	161	+ * sp and the ABI. Be careful: we're in NMI context, and we're
	162	+ * considering current to be the current task, so we should
	163	+ * be careful not to look at any other percpu variables that might
	164	+ * change during context switches.
	165	+ */
	166	+ if (IS_ENABLED(CONFIG_IA32_EMULATION) &&
	167	+ task_thread_info(current)->status & TS_COMPAT) {
	168	+ /* Easy case: we're in a compat syscall. */
	169	+ regs_user->abi = PERF_SAMPLE_REGS_ABI_32;
	170	+ regs_user_copy->sp = user_regs->sp;
	171	+ regs_user_copy->cs = user_regs->cs;
	172	+ regs_user_copy->ss = user_regs->ss;
	173	+ } else if (user_regs->orig_ax != -1) {
	174	+ /*
	175	+ * We're probably in a 64-bit syscall.
	176	+ * Warning: this code is severely racy. At least it's better
	177	+ * than just blindly copying user_regs.
	178	+ */
	179	+ regs_user->abi = PERF_SAMPLE_REGS_ABI_64;
	180	+ regs_user_copy->sp = this_cpu_read(old_rsp);
	181	+ regs_user_copy->cs = __USER_CS;
	182	+ regs_user_copy->ss = __USER_DS;
	183	+ regs_user_copy->cx = -1; /* usually contains garbage */
	184	+ } else {
	185	+ /* We're probably in an interrupt or exception. */
	186	+ regs_user->abi = user_64bit_mode(user_regs) ?
	187	+ PERF_SAMPLE_REGS_ABI_64 : PERF_SAMPLE_REGS_ABI_32;
	188	+ regs_user_copy->sp = user_regs->sp;
	189	+ regs_user_copy->cs = user_regs->cs;
	190	+ regs_user_copy->ss = user_regs->ss;
	191	+ }
	192	+
	193	+ regs_user->regs = regs_user_copy;
104	194	}
105	195	#endif /* CONFIG_X86_32 */
...	...	@@ -28,7 +28,7 @@
28	28
29	29	/* Verify next sizeof(t) bytes can be on the same instruction */
30	30	#define validate_next(t, insn, n) \
31		- ((insn)->next_byte + sizeof(t) + n < (insn)->end_kaddr)
	31	+ ((insn)->next_byte + sizeof(t) + n <= (insn)->end_kaddr)
32	32
33	33	#define __get_next(t, insn) \
34	34	({ t r = (t)insn->next_byte; insn->next_byte += sizeof(t); r; })
...	...	@@ -79,11 +79,6 @@
79	79	struct perf_branch_entry entries[0];
80	80	};
81	81
82		-struct perf_regs {
83		- __u64 abi;
84		- struct pt_regs *regs;
85		-};
86		-
87	82	struct task_struct;
88	83
89	84	/*
90	85
...	...	@@ -610,7 +605,14 @@
610	605	u32 reserved;
611	606	} cpu_entry;
612	607	struct perf_callchain_entry *callchain;
	608	+
	609	+ /*
	610	+ * regs_user may point to task_pt_regs or to regs_user_copy, depending
	611	+ * on arch details.
	612	+ */
613	613	struct perf_regs regs_user;
	614	+ struct pt_regs regs_user_copy;
	615	+
614	616	struct perf_regs regs_intr;
615	617	u64 stack_user_size;
616	618	} ____cacheline_aligned;
1	1	#ifndef _LINUX_PERF_REGS_H
2	2	#define _LINUX_PERF_REGS_H
3	3
	4	+struct perf_regs {
	5	+ __u64 abi;
	6	+ struct pt_regs *regs;
	7	+};
	8	+
4	9	#ifdef CONFIG_HAVE_PERF_REGS
5	10	#include <asm/perf_regs.h>
6	11	u64 perf_reg_value(struct pt_regs *regs, int idx);
7	12	int perf_reg_validate(u64 mask);
8	13	u64 perf_reg_abi(struct task_struct *task);
	14	+void perf_get_regs_user(struct perf_regs *regs_user,
	15	+ struct pt_regs *regs,
	16	+ struct pt_regs *regs_user_copy);
9	17	#else
10	18	static inline u64 perf_reg_value(struct pt_regs *regs, int idx)
11	19	{
...	...	@@ -20,6 +28,14 @@
20	28	static inline u64 perf_reg_abi(struct task_struct *task)
21	29	{
22	30	return PERF_SAMPLE_REGS_ABI_NONE;
	31	+}
	32	+
	33	+static inline void perf_get_regs_user(struct perf_regs *regs_user,
	34	+ struct pt_regs *regs,
	35	+ struct pt_regs *regs_user_copy)
	36	+{
	37	+ regs_user->regs = task_pt_regs(current);
	38	+ regs_user->abi = perf_reg_abi(current);
23	39	}
24	40	#endif /* CONFIG_HAVE_PERF_REGS */
25	41	#endif /* _LINUX_PERF_REGS_H */
...	...	@@ -4461,18 +4461,14 @@
4461	4461	}
4462	4462
4463	4463	static void perf_sample_regs_user(struct perf_regs *regs_user,
4464		- struct pt_regs *regs)
	4464	+ struct pt_regs *regs,
	4465	+ struct pt_regs *regs_user_copy)
4465	4466	{
4466		- if (!user_mode(regs)) {
4467		- if (current->mm)
4468		- regs = task_pt_regs(current);
4469		- else
4470		- regs = NULL;
4471		- }
4472		-
4473		- if (regs) {
4474		- regs_user->abi = perf_reg_abi(current);
	4467	+ if (user_mode(regs)) {
	4468	+ regs_user->abi = perf_reg_abi(current);
4475	4469	regs_user->regs = regs;
	4470	+ } else if (current->mm) {
	4471	+ perf_get_regs_user(regs_user, regs, regs_user_copy);
4476	4472	} else {
4477	4473	regs_user->abi = PERF_SAMPLE_REGS_ABI_NONE;
4478	4474	regs_user->regs = NULL;
...	...	@@ -4951,7 +4947,8 @@
4951	4947	}
4952	4948
4953	4949	if (sample_type & (PERF_SAMPLE_REGS_USER \| PERF_SAMPLE_STACK_USER))
4954		- perf_sample_regs_user(&data->regs_user, regs);
	4950	+ perf_sample_regs_user(&data->regs_user, regs,
	4951	+ &data->regs_user_copy);
4955	4952
4956	4953	if (sample_type & PERF_SAMPLE_REGS_USER) {
4957	4954	/* regs dump ABI info */
...	...	@@ -232,7 +232,7 @@
232	232	if (nr_samples > 0) {
233	233	total_nr_samples += nr_samples;
234	234	hists__collapse_resort(hists, NULL);
235		- hists__output_resort(hists);
	235	+ hists__output_resort(hists, NULL);
236	236
237	237	if (symbol_conf.event_group &&
238	238	!perf_evsel__is_group_leader(pos))