Merge branch 'perf/urgent' of git://git.kernel.org/pub/scm/linux/kernel/git/acme/linux into perf/urgent

Pull perf tooling fixes from Arnaldo Carvalho de Melo:

"- Fix window dimensions change handling in 'perf top' (Jiri Olsa)

- Fix 'perf record -c/-F' options for CPU event aliases (Andi Kleen)

- Generate PERF_RECORD_{MMAP,COMM,EXEC} with 'perf record --delay'
  fixing symbol resolution for processes created, maps put in place
  while --delay happens (Arnaldo Carvalho de Melo)

- Fix up leftover perf_evsel_stat usage via evsel->priv, plugging
  a SEGV when using event groups as in:

     $ perf stat -e '{cpu-clock,instructions}' workload

- Fix 'perf script --per-event-dump' for auxtrace synth evsels (Arnaldo Carvalho de Melo)

- Ignore kptr_restrict when not sampling the kernel (Arnaldo Carvalho de Melo)

- Synchronize kernel ABI headers wrt SPDX tags and ABI changes,
  taking minimal action to handle new syscall args and silencing
  perf build warnings (Arnaldo Carvalho de Melo, Ingo Molnar)

- Fix header.size for namespace events (Jiri Olsa)

- Fix a bug during strstart() conversion in 'perf help' (Namhyung Kim)

- Do not truncate instruction names at 6 chars in 'perf annotate', there
  are really long instruction names in PPC (Ravi Bangoria)

- Fixup discontiguous/sparse numa nodes in 'perf bench numa' (Satheesh Rajendran)

- Fix an exit code of trace__symbols_init in 'perf trace' (Andrei Vagin)

- Fix 'perf test' entries on s/390 (Thomas Richter)

- Bring instruction decoder files used by Intel PT into line with the kernel,
  silencing build warning (Adrian Hunter)"

Signed-off-by: Ingo Molnar <mingo@kernel.org>

21 files changed, 212 insertions, 58 deletions

diff --git a/tools/perf/bench/numa.c b/tools/perf/bench/numa.c
index d95fdcc26f4b..944070e98a2c 100644
--- a/tools/perf/bench/numa.c
+++ b/tools/perf/bench/numa.c
@@ -216,6 +216,47 @@ static const char * const numa_usage[] = {
         NULL
 };
 
+/*
+ * To get number of numa nodes present.
+ */
+static int nr_numa_nodes(void)
+{
+        int i, nr_nodes = 0;
+
+        for (i = 0; i < g->p.nr_nodes; i++) {
+                if (numa_bitmask_isbitset(numa_nodes_ptr, i))
+                        nr_nodes++;
+        }
+
+        return nr_nodes;
+}
+
+/*
+ * To check if given numa node is present.
+ */
+static int is_node_present(int node)
+{
+        return numa_bitmask_isbitset(numa_nodes_ptr, node);
+}
+
+/*
+ * To check given numa node has cpus.
+ */
+static bool node_has_cpus(int node)
+{
+        struct bitmask *cpu = numa_allocate_cpumask();
+        unsigned int i;
+
+        if (cpu && !numa_node_to_cpus(node, cpu)) {
+                for (i = 0; i < cpu->size; i++) {
+                        if (numa_bitmask_isbitset(cpu, i))
+                                return true;
+                }
+        }
+
+        return false; /* lets fall back to nocpus safely */
+}
+
 static cpu_set_t bind_to_cpu(int target_cpu)
 {
         cpu_set_t orig_mask, mask;
@@ -244,12 +285,12 @@ static cpu_set_t bind_to_cpu(int target_cpu)
 
 static cpu_set_t bind_to_node(int target_node)
 {
-        int cpus_per_node = g->p.nr_cpus/g->p.nr_nodes;
+        int cpus_per_node = g->p.nr_cpus / nr_numa_nodes();
         cpu_set_t orig_mask, mask;
         int cpu;
         int ret;
 
-        BUG_ON(cpus_per_node*g->p.nr_nodes != g->p.nr_cpus);
+        BUG_ON(cpus_per_node * nr_numa_nodes() != g->p.nr_cpus);
         BUG_ON(!cpus_per_node);
 
         ret = sched_getaffinity(0, sizeof(orig_mask), &orig_mask);
@@ -649,7 +690,7 @@ static int parse_setup_node_list(void)
                         int i;
 
                         for (i = 0; i < mul; i++) {
-                                if (t >= g->p.nr_tasks) {
+                                if (t >= g->p.nr_tasks || !node_has_cpus(bind_node)) {
                                         printf("\n# NOTE: ignoring bind NODEs starting at NODE#%d\n", bind_node);
                                         goto out;
                                 }
@@ -964,6 +1005,8 @@ static void calc_convergence(double runtime_ns_max, double *convergence)
         sum = 0;
 
         for (node = 0; node < g->p.nr_nodes; node++) {
+                if (!is_node_present(node))
+                        continue;
                 nr = nodes[node];
                 nr_min = min(nr, nr_min);
                 nr_max = max(nr, nr_max);
@@ -984,8 +1027,11 @@ static void calc_convergence(double runtime_ns_max, double *convergence)
         process_groups = 0;
 
         for (node = 0; node < g->p.nr_nodes; node++) {
-                int processes = count_node_processes(node);
+                int processes;
 
+                if (!is_node_present(node))
+                        continue;
+                processes = count_node_processes(node);
                 nr = nodes[node];
                 tprintf(" %2d/%-2d", nr, processes);
 
@@ -1291,7 +1337,7 @@ static void print_summary(void)
 
         printf("\n ###\n");
         printf(" # %d %s will execute (on %d nodes, %d CPUs):\n",
-                g->p.nr_tasks, g->p.nr_tasks == 1 ? "task" : "tasks", g->p.nr_nodes, g->p.nr_cpus);
+                g->p.nr_tasks, g->p.nr_tasks == 1 ? "task" : "tasks", nr_numa_nodes(), g->p.nr_cpus);
         printf(" #      %5dx %5ldMB global  shared mem operations\n",
                         g->p.nr_loops, g->p.bytes_global/1024/1024);
         printf(" #      %5dx %5ldMB process shared mem operations\n",
diff --git a/tools/perf/builtin-help.c b/tools/perf/builtin-help.c
index bd1fedef3d1c..a0f7ed2b869b 100644
--- a/tools/perf/builtin-help.c
+++ b/tools/perf/builtin-help.c
@@ -284,7 +284,7 @@ static int perf_help_config(const char *var, const char *value, void *cb)
                 add_man_viewer(value);
                 return 0;
         }
-        if (!strstarts(var, "man."))
+        if (strstarts(var, "man."))
                 return add_man_viewer_info(var, value);
 
         return 0;
@@ -314,7 +314,7 @@ static const char *cmd_to_page(const char *perf_cmd)
 
         if (!perf_cmd)
                 return "perf";
-        else if (!strstarts(perf_cmd, "perf"))
+        else if (strstarts(perf_cmd, "perf"))
                 return perf_cmd;
 
         return asprintf(&s, "perf-%s", perf_cmd) < 0 ? NULL : s;
diff --git a/tools/perf/builtin-record.c b/tools/perf/builtin-record.c
index 3d7f33e19df2..003255910c05 100644
--- a/tools/perf/builtin-record.c
+++ b/tools/perf/builtin-record.c
@@ -339,6 +339,22 @@ static int record__open(struct record *rec)
         struct perf_evsel_config_term *err_term;
         int rc = 0;
 
+        /*
+         * For initial_delay we need to add a dummy event so that we can track
+         * PERF_RECORD_MMAP while we wait for the initial delay to enable the
+         * real events, the ones asked by the user.
+         */
+        if (opts->initial_delay) {
+                if (perf_evlist__add_dummy(evlist))
+                        return -ENOMEM;
+
+                pos = perf_evlist__first(evlist);
+                pos->tracking = 0;
+                pos = perf_evlist__last(evlist);
+                pos->tracking = 1;
+                pos->attr.enable_on_exec = 1;
+        }
+
         perf_evlist__config(evlist, opts, &callchain_param);
 
         evlist__for_each_entry(evlist, pos) {
@@ -749,17 +765,19 @@ static int record__synthesize(struct record *rec, bool tail)
                         goto out;
         }
 
-        err = perf_event__synthesize_kernel_mmap(tool, process_synthesized_event,
-                                                 machine);
-        WARN_ONCE(err < 0, "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(tool, process_synthesized_event,
-                                             machine);
-        WARN_ONCE(err < 0, "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_evlist__exclude_kernel(rec->evlist)) {
+                err = perf_event__synthesize_kernel_mmap(tool, process_synthesized_event,
+                                                         machine);
+                WARN_ONCE(err < 0, "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(tool, process_synthesized_event,
+                                                     machine);
+                WARN_ONCE(err < 0, "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) {
                 machines__process_guests(&session->machines,
@@ -1693,7 +1711,7 @@ int cmd_record(int argc, const char **argv)
 
         err = -ENOMEM;
 
-        if (symbol_conf.kptr_restrict)
+        if (symbol_conf.kptr_restrict && !perf_evlist__exclude_kernel(rec->evlist))
                 pr_warning(
 "WARNING: Kernel address maps (/proc/{kallsyms,modules}) are restricted,\n"
 "check /proc/sys/kernel/kptr_restrict.\n\n"
diff --git a/tools/perf/builtin-report.c b/tools/perf/builtin-report.c
index 1394cd8d96f7..af5dd038195e 100644
--- a/tools/perf/builtin-report.c
+++ b/tools/perf/builtin-report.c
@@ -441,6 +441,9 @@ static void report__warn_kptr_restrict(const struct report *rep)
         struct map *kernel_map = machine__kernel_map(&rep->session->machines.host);
         struct kmap *kernel_kmap = kernel_map ? map__kmap(kernel_map) : NULL;
 
+        if (perf_evlist__exclude_kernel(rep->session->evlist))
+                return;
+
         if (kernel_map == NULL ||
             (kernel_map->dso->hit &&
              (kernel_kmap->ref_reloc_sym == NULL ||
diff --git a/tools/perf/builtin-script.c b/tools/perf/builtin-script.c
index 68f36dc0344f..9b43bda45a41 100644
--- a/tools/perf/builtin-script.c
+++ b/tools/perf/builtin-script.c
@@ -1955,6 +1955,16 @@ static int perf_script__fopen_per_event_dump(struct perf_script *script)
         struct perf_evsel *evsel;
 
         evlist__for_each_entry(script->session->evlist, evsel) {
+                /*
+                 * Already setup? I.e. we may be called twice in cases like
+                 * Intel PT, one for the intel_pt// and dummy events, then
+                 * for the evsels syntheized from the auxtrace info.
+                 *
+                 * Ses perf_script__process_auxtrace_info.
+                 */
+                if (evsel->priv != NULL)
+                        continue;
+
                 evsel->priv = perf_evsel_script__new(evsel, script->session->data);
                 if (evsel->priv == NULL)
                         goto out_err_fclose;
@@ -2838,6 +2848,25 @@ int process_cpu_map_event(struct perf_tool *tool __maybe_unused,
         return set_maps(script);
 }
 
+#ifdef HAVE_AUXTRACE_SUPPORT
+static int perf_script__process_auxtrace_info(struct perf_tool *tool,
+                                              union perf_event *event,
+                                              struct perf_session *session)
+{
+        int ret = perf_event__process_auxtrace_info(tool, event, session);
+
+        if (ret == 0) {
+                struct perf_script *script = container_of(tool, struct perf_script, tool);
+
+                ret = perf_script__setup_per_event_dump(script);
+        }
+
+        return ret;
+}
+#else
+#define perf_script__process_auxtrace_info 0
+#endif
+
 int cmd_script(int argc, const char **argv)
 {
         bool show_full_info = false;
@@ -2866,7 +2895,7 @@ int cmd_script(int argc, const char **argv)
                         .feature         = perf_event__process_feature,
                         .build_id        = perf_event__process_build_id,
                         .id_index        = perf_event__process_id_index,
-                        .auxtrace_info   = perf_event__process_auxtrace_info,
+                        .auxtrace_info   = perf_script__process_auxtrace_info,
                         .auxtrace        = perf_event__process_auxtrace,
                         .auxtrace_error  = perf_event__process_auxtrace_error,
                         .stat            = perf_event__process_stat_event,
diff --git a/tools/perf/builtin-top.c b/tools/perf/builtin-top.c
index 477a8699f0b5..9e0d2645ae13 100644
--- a/tools/perf/builtin-top.c
+++ b/tools/perf/builtin-top.c
@@ -77,6 +77,7 @@
 #include "sane_ctype.h"
 
 static volatile int done;
+static volatile int resize;
 
 #define HEADER_LINE_NR  5
 
@@ -85,11 +86,13 @@ static void perf_top__update_print_entries(struct perf_top *top)
         top->print_entries = top->winsize.ws_row - HEADER_LINE_NR;
 }
 
-static void perf_top__sig_winch(int sig __maybe_unused,
-                                siginfo_t *info __maybe_unused, void *arg)
+static void winch_sig(int sig __maybe_unused)
 {
-        struct perf_top *top = arg;
+        resize = 1;
+}
 
+static void perf_top__resize(struct perf_top *top)
+{
         get_term_dimensions(&top->winsize);
         perf_top__update_print_entries(top);
 }
@@ -473,12 +476,8 @@ static bool perf_top__handle_keypress(struct perf_top *top, int c)
                 case 'e':
                         prompt_integer(&top->print_entries, "Enter display entries (lines)");
                         if (top->print_entries == 0) {
-                                struct sigaction act = {
-                                        .sa_sigaction = perf_top__sig_winch,
-                                        .sa_flags     = SA_SIGINFO,
-                                };
-                                perf_top__sig_winch(SIGWINCH, NULL, top);
-                                sigaction(SIGWINCH, &act, NULL);
+                                perf_top__resize(top);
+                                signal(SIGWINCH, winch_sig);
                         } else {
                                 signal(SIGWINCH, SIG_DFL);
                         }
@@ -732,14 +731,16 @@ static void perf_event__process_sample(struct perf_tool *tool,
         if (!machine->kptr_restrict_warned &&
             symbol_conf.kptr_restrict &&
             al.cpumode == PERF_RECORD_MISC_KERNEL) {
-                ui__warning(
+                if (!perf_evlist__exclude_kernel(top->session->evlist)) {
+                        ui__warning(
 "Kernel address maps (/proc/{kallsyms,modules}) are restricted.\n\n"
 "Check /proc/sys/kernel/kptr_restrict.\n\n"
 "Kernel%s samples will not be resolved.\n",
                           al.map && !RB_EMPTY_ROOT(&al.map->dso->symbols[MAP__FUNCTION]) ?
                           " modules" : "");
-                if (use_browser <= 0)
-                        sleep(5);
+                        if (use_browser <= 0)
+                                sleep(5);
+                }
                 machine->kptr_restrict_warned = true;
         }
 
@@ -1030,6 +1031,11 @@ static int __cmd_top(struct perf_top *top)
 
                 if (hits == top->samples)
                         ret = perf_evlist__poll(top->evlist, 100);
+
+                if (resize) {
+                        perf_top__resize(top);
+                        resize = 0;
+                }
         }
 
         ret = 0;
@@ -1352,12 +1358,8 @@ int cmd_top(int argc, const char **argv)
 
         get_term_dimensions(&top.winsize);
         if (top.print_entries == 0) {
-                struct sigaction act = {
-                        .sa_sigaction = perf_top__sig_winch,
-                        .sa_flags     = SA_SIGINFO,
-                };
                 perf_top__update_print_entries(&top);
-                sigaction(SIGWINCH, &act, NULL);
+                signal(SIGWINCH, winch_sig);
         }
 
         status = __cmd_top(&top);
diff --git a/tools/perf/builtin-trace.c b/tools/perf/builtin-trace.c
index f2757d38c7d7..84debdbad327 100644
--- a/tools/perf/builtin-trace.c
+++ b/tools/perf/builtin-trace.c
@@ -1152,12 +1152,14 @@ static int trace__symbols_init(struct trace *trace, struct perf_evlist *evlist)
         if (trace->host == NULL)
                 return -ENOMEM;
 
-        if (trace_event__register_resolver(trace->host, trace__machine__resolve_kernel_addr) < 0)
-                return -errno;
+        err = trace_event__register_resolver(trace->host, trace__machine__resolve_kernel_addr);
+        if (err < 0)
+                goto out;
 
         err = __machine__synthesize_threads(trace->host, &trace->tool, &trace->opts.target,
                                             evlist->threads, trace__tool_process, false,
                                             trace->opts.proc_map_timeout, 1);
+out:
         if (err)
                 symbol__exit();
 
diff --git a/tools/perf/tests/shell/trace+probe_libc_inet_pton.sh b/tools/perf/tests/shell/trace+probe_libc_inet_pton.sh
index 7a84d73324e3..8b3da21a08f1 100755
--- a/tools/perf/tests/shell/trace+probe_libc_inet_pton.sh
+++ b/tools/perf/tests/shell/trace+probe_libc_inet_pton.sh
@@ -10,8 +10,8 @@
 
 . $(dirname $0)/lib/probe.sh
 
-ld=$(realpath /lib64/ld*.so.* | uniq)
-libc=$(echo $ld | sed 's/ld/libc/g')
+libc=$(grep -w libc /proc/self/maps | head -1 | sed -r 's/.*[[:space:]](\/.*)/\1/g')
+nm -g $libc 2>/dev/null | fgrep -q inet_pton || exit 254
 
 trace_libc_inet_pton_backtrace() {
         idx=0
@@ -37,6 +37,9 @@ trace_libc_inet_pton_backtrace() {
         done
 }
 
+# Check for IPv6 interface existence
+ip a sh lo | fgrep -q inet6 || exit 2
+
 skip_if_no_perf_probe && \
 perf probe -q $libc inet_pton && \
 trace_libc_inet_pton_backtrace
diff --git a/tools/perf/tests/shell/trace+probe_vfs_getname.sh b/tools/perf/tests/shell/trace+probe_vfs_getname.sh
index 2e68c5f120da..2a9ef080efd0 100755
--- a/tools/perf/tests/shell/trace+probe_vfs_getname.sh
+++ b/tools/perf/tests/shell/trace+probe_vfs_getname.sh
@@ -17,8 +17,10 @@ skip_if_no_perf_probe || exit 2
 file=$(mktemp /tmp/temporary_file.XXXXX)
 
 trace_open_vfs_getname() {
-        perf trace -e open touch $file 2>&1 | \
-        egrep " +[0-9]+\.[0-9]+ +\( +[0-9]+\.[0-9]+ ms\): +touch\/[0-9]+ open\(filename: +${file}, +flags: CREAT\|NOCTTY\|NONBLOCK\|WRONLY, +mode: +IRUGO\|IWUGO\) += +[0-9]+$"
+        test "$(uname -m)" = s390x && { svc="openat"; txt="dfd: +CWD, +"; }
+
+        perf trace -e ${svc:-open} touch $file 2>&1 | \
+        egrep " +[0-9]+\.[0-9]+ +\( +[0-9]+\.[0-9]+ ms\): +touch\/[0-9]+ ${svc:-open}\(${txt}filename: +${file}, +flags: CREAT\|NOCTTY\|NONBLOCK\|WRONLY, +mode: +IRUGO\|IWUGO\) += +[0-9]+$"
 }
 
 
diff --git a/tools/perf/tests/task-exit.c b/tools/perf/tests/task-exit.c
index bc4a7344e274..89c8e1604ca7 100644
--- a/tools/perf/tests/task-exit.c
+++ b/tools/perf/tests/task-exit.c
@@ -84,7 +84,11 @@ int test__task_exit(struct test *test __maybe_unused, int subtest __maybe_unused
 
         evsel = perf_evlist__first(evlist);
         evsel->attr.task = 1;
+#ifdef __s390x__
+        evsel->attr.sample_freq = 1000000;
+#else
         evsel->attr.sample_freq = 1;
+#endif
         evsel->attr.inherit = 0;
         evsel->attr.watermark = 0;
         evsel->attr.wakeup_events = 1;
diff --git a/tools/perf/trace/beauty/mmap.c b/tools/perf/trace/beauty/mmap.c
index 9e1668b2c5d7..417e3ecfe9d7 100644
--- a/tools/perf/trace/beauty/mmap.c
+++ b/tools/perf/trace/beauty/mmap.c
@@ -62,6 +62,9 @@ static size_t syscall_arg__scnprintf_mmap_flags(char *bf, size_t size,
         P_MMAP_FLAG(POPULATE);
         P_MMAP_FLAG(STACK);
         P_MMAP_FLAG(UNINITIALIZED);
+#ifdef MAP_SYNC
+        P_MMAP_FLAG(SYNC);
+#endif
 #undef P_MMAP_FLAG
 
         if (flags)
diff --git a/tools/perf/util/annotate.c b/tools/perf/util/annotate.c
index da1c4c4a0dd8..3369c7830260 100644
--- a/tools/perf/util/annotate.c
+++ b/tools/perf/util/annotate.c
@@ -165,7 +165,7 @@ static void ins__delete(struct ins_operands *ops)
 static int ins__raw_scnprintf(struct ins *ins, char *bf, size_t size,
                               struct ins_operands *ops)
 {
-        return scnprintf(bf, size, "%-6.6s %s", ins->name, ops->raw);
+        return scnprintf(bf, size, "%-6s %s", ins->name, ops->raw);
 }
 
 int ins__scnprintf(struct ins *ins, char *bf, size_t size,
@@ -230,12 +230,12 @@ static int call__scnprintf(struct ins *ins, char *bf, size_t size,
                            struct ins_operands *ops)
 {
         if (ops->target.name)
-                return scnprintf(bf, size, "%-6.6s %s", ins->name, ops->target.name);
+                return scnprintf(bf, size, "%-6s %s", ins->name, ops->target.name);
 
         if (ops->target.addr == 0)
                 return ins__raw_scnprintf(ins, bf, size, ops);
 
-        return scnprintf(bf, size, "%-6.6s *%" PRIx64, ins->name, ops->target.addr);
+        return scnprintf(bf, size, "%-6s *%" PRIx64, ins->name, ops->target.addr);
 }
 
 static struct ins_ops call_ops = {
@@ -299,7 +299,7 @@ static int jump__scnprintf(struct ins *ins, char *bf, size_t size,
                         c++;
         }
 
-        return scnprintf(bf, size, "%-6.6s %.*s%" PRIx64,
+        return scnprintf(bf, size, "%-6s %.*s%" PRIx64,
                          ins->name, c ? c - ops->raw : 0, ops->raw,
                          ops->target.offset);
 }
@@ -372,7 +372,7 @@ static int lock__scnprintf(struct ins *ins, char *bf, size_t size,
         if (ops->locked.ins.ops == NULL)
                 return ins__raw_scnprintf(ins, bf, size, ops);
 
-        printed = scnprintf(bf, size, "%-6.6s ", ins->name);
+        printed = scnprintf(bf, size, "%-6s ", ins->name);
         return printed + ins__scnprintf(&ops->locked.ins, bf + printed,
                                         size - printed, ops->locked.ops);
 }
@@ -448,7 +448,7 @@ out_free_source:
 static int mov__scnprintf(struct ins *ins, char *bf, size_t size,
                            struct ins_operands *ops)
 {
-        return scnprintf(bf, size, "%-6.6s %s,%s", ins->name,
+        return scnprintf(bf, size, "%-6s %s,%s", ins->name,
                          ops->source.name ?: ops->source.raw,
                          ops->target.name ?: ops->target.raw);
 }
@@ -488,7 +488,7 @@ static int dec__parse(struct arch *arch __maybe_unused, struct ins_operands *ops
 static int dec__scnprintf(struct ins *ins, char *bf, size_t size,
                            struct ins_operands *ops)
 {
-        return scnprintf(bf, size, "%-6.6s %s", ins->name,
+        return scnprintf(bf, size, "%-6s %s", ins->name,
                          ops->target.name ?: ops->target.raw);
 }
 
@@ -500,7 +500,7 @@ static struct ins_ops dec_ops = {
 static int nop__scnprintf(struct ins *ins __maybe_unused, char *bf, size_t size,
                           struct ins_operands *ops __maybe_unused)
 {
-        return scnprintf(bf, size, "%-6.6s", "nop");
+        return scnprintf(bf, size, "%-6s", "nop");
 }
 
 static struct ins_ops nop_ops = {
@@ -924,7 +924,7 @@ void disasm_line__free(struct disasm_line *dl)
 int disasm_line__scnprintf(struct disasm_line *dl, char *bf, size_t size, bool raw)
 {
         if (raw || !dl->ins.ops)
-                return scnprintf(bf, size, "%-6.6s %s", dl->ins.name, dl->ops.raw);
+                return scnprintf(bf, size, "%-6s %s", dl->ins.name, dl->ops.raw);
 
         return ins__scnprintf(&dl->ins, bf, size, &dl->ops);
 }
diff --git a/tools/perf/util/evlist.c b/tools/perf/util/evlist.c
index c6c891e154a6..b62e523a7035 100644
--- a/tools/perf/util/evlist.c
+++ b/tools/perf/util/evlist.c
@@ -257,7 +257,7 @@ int perf_evlist__add_dummy(struct perf_evlist *evlist)
                 .config = PERF_COUNT_SW_DUMMY,
                 .size   = sizeof(attr), /* to capture ABI version */
         };
-        struct perf_evsel *evsel = perf_evsel__new(&attr);
+        struct perf_evsel *evsel = perf_evsel__new_idx(&attr, evlist->nr_entries);
 
         if (evsel == NULL)
                 return -ENOMEM;
@@ -1786,3 +1786,15 @@ void perf_evlist__toggle_bkw_mmap(struct perf_evlist *evlist,
 state_err:
         return;
 }
+
+bool perf_evlist__exclude_kernel(struct perf_evlist *evlist)
+{
+        struct perf_evsel *evsel;
+
+        evlist__for_each_entry(evlist, evsel) {
+                if (!evsel->attr.exclude_kernel)
+                        return false;
+        }
+
+        return true;
+}
diff --git a/tools/perf/util/evlist.h b/tools/perf/util/evlist.h
index e72ae64c11ac..491f69542920 100644
--- a/tools/perf/util/evlist.h
+++ b/tools/perf/util/evlist.h
@@ -312,4 +312,6 @@ perf_evlist__find_evsel_by_str(struct perf_evlist *evlist, const char *str);
 
 struct perf_evsel *perf_evlist__event2evsel(struct perf_evlist *evlist,
                                             union perf_event *event);
+
+bool perf_evlist__exclude_kernel(struct perf_evlist *evlist);
 #endif /* __PERF_EVLIST_H */
diff --git a/tools/perf/util/evsel.c b/tools/perf/util/evsel.c
index f894893c203d..d5fbcf8c7aa7 100644
--- a/tools/perf/util/evsel.c
+++ b/tools/perf/util/evsel.c
@@ -733,12 +733,16 @@ static void apply_config_terms(struct perf_evsel *evsel,
         list_for_each_entry(term, config_terms, list) {
                 switch (term->type) {
                 case PERF_EVSEL__CONFIG_TERM_PERIOD:
-                        attr->sample_period = term->val.period;
-                        attr->freq = 0;
+                        if (!(term->weak && opts->user_interval != ULLONG_MAX)) {
+                                attr->sample_period = term->val.period;
+                                attr->freq = 0;
+                        }
                         break;
                 case PERF_EVSEL__CONFIG_TERM_FREQ:
-                        attr->sample_freq = term->val.freq;
-                        attr->freq = 1;
+                        if (!(term->weak && opts->user_freq != UINT_MAX)) {
+                                attr->sample_freq = term->val.freq;
+                                attr->freq = 1;
+                        }
                         break;
                 case PERF_EVSEL__CONFIG_TERM_TIME:
                         if (term->val.time)
@@ -1371,7 +1375,7 @@ perf_evsel__process_group_data(struct perf_evsel *leader,
 static int
 perf_evsel__read_group(struct perf_evsel *leader, int cpu, int thread)
 {
-        struct perf_stat_evsel *ps = leader->priv;
+        struct perf_stat_evsel *ps = leader->stats;
         u64 read_format = leader->attr.read_format;
         int size = perf_evsel__read_size(leader);
         u64 *data = ps->group_data;
diff --git a/tools/perf/util/evsel.h b/tools/perf/util/evsel.h
index 9277df96ffda..157f49e8a772 100644
--- a/tools/perf/util/evsel.h
+++ b/tools/perf/util/evsel.h
@@ -67,6 +67,7 @@ struct perf_evsel_config_term {
                 bool    overwrite;
                 char    *branch;
         } val;
+        bool weak;
 };
 
 struct perf_stat_evsel;
diff --git a/tools/perf/util/intel-pt-decoder/inat.h b/tools/perf/util/intel-pt-decoder/inat.h
index 125ecd2a300d..52dc8d911173 100644
--- a/tools/perf/util/intel-pt-decoder/inat.h
+++ b/tools/perf/util/intel-pt-decoder/inat.h
@@ -97,6 +97,16 @@
 #define INAT_MAKE_GROUP(grp)    ((grp << INAT_GRP_OFFS) | INAT_MODRM)
 #define INAT_MAKE_IMM(imm)      (imm << INAT_IMM_OFFS)
 
+/* Identifiers for segment registers */
+#define INAT_SEG_REG_IGNORE     0
+#define INAT_SEG_REG_DEFAULT    1
+#define INAT_SEG_REG_CS         2
+#define INAT_SEG_REG_SS         3
+#define INAT_SEG_REG_DS         4
+#define INAT_SEG_REG_ES         5
+#define INAT_SEG_REG_FS         6
+#define INAT_SEG_REG_GS         7
+
 /* Attribute search APIs */
 extern insn_attr_t inat_get_opcode_attribute(insn_byte_t opcode);
 extern int inat_get_last_prefix_id(insn_byte_t last_pfx);
diff --git a/tools/perf/util/machine.c b/tools/perf/util/machine.c
index 6a8d03c3d9b7..270f3223c6df 100644
--- a/tools/perf/util/machine.c
+++ b/tools/perf/util/machine.c
@@ -172,6 +172,9 @@ void machine__exit(struct machine *machine)
 {
         int i;
 
+        if (machine == NULL)
+                return;
+
         machine__destroy_kernel_maps(machine);
         map_groups__exit(&machine->kmaps);
         dsos__exit(&machine->dsos);
diff --git a/tools/perf/util/parse-events.c b/tools/perf/util/parse-events.c
index a7fcd95961ef..170316795a18 100644
--- a/tools/perf/util/parse-events.c
+++ b/tools/perf/util/parse-events.c
@@ -1116,6 +1116,7 @@ do {								\
         INIT_LIST_HEAD(&__t->list);                             \
         __t->type       = PERF_EVSEL__CONFIG_TERM_ ## __type;   \
         __t->val.__name = __val;                                \
+        __t->weak       = term->weak;                           \
         list_add_tail(&__t->list, head_terms);                  \
 } while (0)
 
@@ -2410,6 +2411,7 @@ static int new_term(struct parse_events_term **_term,
 
         *term = *temp;
         INIT_LIST_HEAD(&term->list);
+        term->weak = false;
 
         switch (term->type_val) {
         case PARSE_EVENTS__TERM_TYPE_NUM:
diff --git a/tools/perf/util/parse-events.h b/tools/perf/util/parse-events.h
index be337c266697..88108cd11b4c 100644
--- a/tools/perf/util/parse-events.h
+++ b/tools/perf/util/parse-events.h
@@ -101,6 +101,9 @@ struct parse_events_term {
         /* error string indexes for within parsed string */
         int err_term;
         int err_val;
+
+        /* Coming from implicit alias */
+        bool weak;
 };
 
 struct parse_events_error {
diff --git a/tools/perf/util/pmu.c b/tools/perf/util/pmu.c
index 07cb2ac041d7..80fb1593913a 100644
--- a/tools/perf/util/pmu.c
+++ b/tools/perf/util/pmu.c
@@ -405,6 +405,11 @@ static int pmu_alias_terms(struct perf_pmu_alias *alias,
                         parse_events_terms__purge(&list);
                         return ret;
                 }
+                /*
+                 * Weak terms don't override command line options,
+                 * which we don't want for implicit terms in aliases.
+                 */
+                cloned->weak = true;
                 list_add_tail(&cloned->list, &list);
         }
         list_splice(&list, terms);