Merge tag 'perf-core-for-mingo-4.15-20171003' of git://git.kernel.org/pub/scm/linux/kernel/git/acme/linux into perf/core

Pull perf/core improvements and fixes from Arnaldo Carvalho de Melo:

- Multithread the synthesizing of PERF_RECORD_ events for pre-existing
  threads in 'perf top', speeding up that phase, greatly improving the
  user experience in systems such as Intel's Knights Mill (Kan Liang)

- 'perf test' fixes for the perf_event_attr test case (Jiri Olsa, Thomas Richter)

Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
Signed-off-by: Ingo Molnar <mingo@kernel.org>

29 files changed, 278 insertions, 108 deletions

diff --git a/tools/perf/Documentation/perf-top.txt b/tools/perf/Documentation/perf-top.txt
index d864ea6fd367..4353262bc462 100644
--- a/tools/perf/Documentation/perf-top.txt
+++ b/tools/perf/Documentation/perf-top.txt
@@ -240,6 +240,9 @@ Default is to monitor all CPUS.
 --force::
         Don't do ownership validation.
 
+--num-thread-synthesize::
+        The number of threads to run when synthesizing events for existing processes.
+        By default, the number of threads equals to the number of online CPUs.
 
 INTERACTIVE PROMPTING KEYS
 --------------------------
diff --git a/tools/perf/arch/s390/util/Build b/tools/perf/arch/s390/util/Build
index bd518b623d7a..5bd7b9260cc0 100644
--- a/tools/perf/arch/s390/util/Build
+++ b/tools/perf/arch/s390/util/Build
@@ -1,5 +1,4 @@
 libperf-y += header.o
-libperf-y += sym-handling.o
 libperf-y += kvm-stat.o
 
 libperf-$(CONFIG_DWARF) += dwarf-regs.o
diff --git a/tools/perf/arch/s390/util/sym-handling.c b/tools/perf/arch/s390/util/sym-handling.c
deleted file mode 100644
index e103f6e46afe..000000000000
--- a/tools/perf/arch/s390/util/sym-handling.c
+++ /dev/null
@@ -1,29 +0,0 @@
-/*
- * Architecture specific ELF symbol handling and relocation mapping.
- *
- * Copyright 2017 IBM Corp.
- * Author(s): Thomas Richter <tmricht@linux.vnet.ibm.com>
- *
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License (version 2 only)
- * as published by the Free Software Foundation.
- */
-
-#include "symbol.h"
-
-#ifdef HAVE_LIBELF_SUPPORT
-bool elf__needs_adjust_symbols(GElf_Ehdr ehdr)
-{
-        if (ehdr.e_type == ET_EXEC)
-                return false;
-        return ehdr.e_type == ET_REL || ehdr.e_type == ET_DYN;
-}
-
-void arch__adjust_sym_map_offset(GElf_Sym *sym,
-                                 GElf_Shdr *shdr __maybe_unused,
-                                 struct map *map)
-{
-        if (map->type == MAP__FUNCTION)
-                sym->st_value += map->start;
-}
-#endif
diff --git a/tools/perf/builtin-kvm.c b/tools/perf/builtin-kvm.c
index c747a1af49fe..721f4f91291a 100644
--- a/tools/perf/builtin-kvm.c
+++ b/tools/perf/builtin-kvm.c
@@ -1441,7 +1441,8 @@ static int kvm_events_live(struct perf_kvm_stat *kvm,
         perf_session__set_id_hdr_size(kvm->session);
         ordered_events__set_copy_on_queue(&kvm->session->ordered_events, true);
         machine__synthesize_threads(&kvm->session->machines.host, &kvm->opts.target,
-                                    kvm->evlist->threads, false, kvm->opts.proc_map_timeout);
+                                    kvm->evlist->threads, false,
+                                    kvm->opts.proc_map_timeout, 1);
         err = kvm_live_open_events(kvm);
         if (err)
                 goto out;
diff --git a/tools/perf/builtin-record.c b/tools/perf/builtin-record.c
index 9b379f3a3d99..234fdf4734f6 100644
--- a/tools/perf/builtin-record.c
+++ b/tools/perf/builtin-record.c
@@ -863,7 +863,7 @@ static int record__synthesize(struct record *rec, bool tail)
 
         err = __machine__synthesize_threads(machine, tool, &opts->target, rec->evlist->threads,
                                             process_synthesized_event, opts->sample_address,
-                                            opts->proc_map_timeout);
+                                            opts->proc_map_timeout, 1);
 out:
         return err;
 }
diff --git a/tools/perf/builtin-top.c b/tools/perf/builtin-top.c
index ee954bde7e3e..477a8699f0b5 100644
--- a/tools/perf/builtin-top.c
+++ b/tools/perf/builtin-top.c
@@ -958,8 +958,16 @@ static int __cmd_top(struct perf_top *top)
         if (perf_session__register_idle_thread(top->session) < 0)
                 goto out_delete;
 
+        if (top->nr_threads_synthesize > 1)
+                perf_set_multithreaded();
+
         machine__synthesize_threads(&top->session->machines.host, &opts->target,
-                                    top->evlist->threads, false, opts->proc_map_timeout);
+                                    top->evlist->threads, false,
+                                    opts->proc_map_timeout,
+                                    top->nr_threads_synthesize);
+
+        if (top->nr_threads_synthesize > 1)
+                perf_set_singlethreaded();
 
         if (perf_hpp_list.socket) {
                 ret = perf_env__read_cpu_topology_map(&perf_env);
@@ -1112,6 +1120,7 @@ int cmd_top(int argc, const char **argv)
                 },
                 .max_stack           = sysctl_perf_event_max_stack,
                 .sym_pcnt_filter     = 5,
+                .nr_threads_synthesize = UINT_MAX,
         };
         struct record_opts *opts = &top.record_opts;
         struct target *target = &opts->target;
@@ -1221,6 +1230,8 @@ int cmd_top(int argc, const char **argv)
         OPT_BOOLEAN(0, "hierarchy", &symbol_conf.report_hierarchy,
                     "Show entries in a hierarchy"),
         OPT_BOOLEAN(0, "force", &symbol_conf.force, "don't complain, do it"),
+        OPT_UINTEGER(0, "num-thread-synthesize", &top.nr_threads_synthesize,
+                        "number of thread to run event synthesize"),
         OPT_END()
         };
         const char * const top_usage[] = {
diff --git a/tools/perf/builtin-trace.c b/tools/perf/builtin-trace.c
index 967bd351b58d..afef6fe46c45 100644
--- a/tools/perf/builtin-trace.c
+++ b/tools/perf/builtin-trace.c
@@ -1131,7 +1131,7 @@ static int trace__symbols_init(struct trace *trace, struct perf_evlist *evlist)
 
         err = __machine__synthesize_threads(trace->host, &trace->tool, &trace->opts.target,
                                             evlist->threads, trace__tool_process, false,
-                                            trace->opts.proc_map_timeout);
+                                            trace->opts.proc_map_timeout, 1);
         if (err)
                 symbol__exit();
 
diff --git a/tools/perf/tests/attr.c b/tools/perf/tests/attr.c
index c9aafed7da15..25ede4472465 100644
--- a/tools/perf/tests/attr.c
+++ b/tools/perf/tests/attr.c
@@ -166,7 +166,7 @@ static int run_dir(const char *d, const char *perf)
         snprintf(cmd, 3*PATH_MAX, PYTHON " %s/attr.py -d %s/attr/ -p %s %.*s",
                  d, d, perf, vcnt, v);
 
-        return system(cmd);
+        return system(cmd) ? TEST_FAIL : TEST_OK;
 }
 
 int test__attr(struct test *test __maybe_unused, int subtest __maybe_unused)
diff --git a/tools/perf/tests/attr.py b/tools/perf/tests/attr.py
index 6bb50e82a3e3..a13cd780148e 100644
--- a/tools/perf/tests/attr.py
+++ b/tools/perf/tests/attr.py
@@ -237,6 +237,7 @@ class Test(object):
         # events in result. Fail if there's not any.
         for exp_name, exp_event in expect.items():
             exp_list = []
+            res_event = {}
             log.debug("    matching [%s]" % exp_name)
             for res_name, res_event in result.items():
                 log.debug("      to [%s]" % res_name)
@@ -253,7 +254,10 @@ class Test(object):
                 if exp_event.optional():
                     log.debug("    %s does not match, but is optional" % exp_name)
                 else:
-                    exp_event.diff(res_event)
+                    if not res_event:
+                        log.debug("    res_event is empty");
+                    else:
+                        exp_event.diff(res_event)
                     raise Fail(self, 'match failure');
 
             match[exp_name] = exp_list
diff --git a/tools/perf/tests/attr/base-record b/tools/perf/tests/attr/base-record
index 31e0b1da830b..37940665f736 100644
--- a/tools/perf/tests/attr/base-record
+++ b/tools/perf/tests/attr/base-record
@@ -23,7 +23,7 @@ comm=1
 freq=1
 inherit_stat=0
 enable_on_exec=1
-task=0
+task=1
 watermark=0
 precise_ip=0|1|2|3
 mmap_data=0
diff --git a/tools/perf/tests/attr/test-record-group b/tools/perf/tests/attr/test-record-group
index 6e7961f6f7a5..618ba1c17474 100644
--- a/tools/perf/tests/attr/test-record-group
+++ b/tools/perf/tests/attr/test-record-group
@@ -17,5 +17,6 @@ sample_type=327
 read_format=4
 mmap=0
 comm=0
+task=0
 enable_on_exec=0
 disabled=0
diff --git a/tools/perf/tests/attr/test-record-group-sampling b/tools/perf/tests/attr/test-record-group-sampling
index ef59afd6d635..f906b793196f 100644
--- a/tools/perf/tests/attr/test-record-group-sampling
+++ b/tools/perf/tests/attr/test-record-group-sampling
@@ -23,7 +23,7 @@ sample_type=343
 
 # PERF_FORMAT_ID | PERF_FORMAT_GROUP
 read_format=12
-
+task=0
 mmap=0
 comm=0
 enable_on_exec=0
diff --git a/tools/perf/tests/attr/test-record-group1 b/tools/perf/tests/attr/test-record-group1
index 87a222d014d8..48e8bd12fe46 100644
--- a/tools/perf/tests/attr/test-record-group1
+++ b/tools/perf/tests/attr/test-record-group1
@@ -18,5 +18,6 @@ sample_type=327
 read_format=4
 mmap=0
 comm=0
+task=0
 enable_on_exec=0
 disabled=0
diff --git a/tools/perf/tests/attr/test-stat-group b/tools/perf/tests/attr/test-stat-group
index fdc1596a8862..e15d6946e9b3 100644
--- a/tools/perf/tests/attr/test-stat-group
+++ b/tools/perf/tests/attr/test-stat-group
@@ -6,6 +6,7 @@ ret     = 1
 [event-1:base-stat]
 fd=1
 group_fd=-1
+read_format=3|15
 
 [event-2:base-stat]
 fd=2
@@ -13,3 +14,4 @@ group_fd=1
 config=1
 disabled=0
 enable_on_exec=0
+read_format=3|15
diff --git a/tools/perf/tests/attr/test-stat-group1 b/tools/perf/tests/attr/test-stat-group1
index 2a1f86e4a904..1746751123dc 100644
--- a/tools/perf/tests/attr/test-stat-group1
+++ b/tools/perf/tests/attr/test-stat-group1
@@ -6,6 +6,7 @@ ret     = 1
 [event-1:base-stat]
 fd=1
 group_fd=-1
+read_format=3|15
 
 [event-2:base-stat]
 fd=2
@@ -13,3 +14,4 @@ group_fd=1
 config=1
 disabled=0
 enable_on_exec=0
+read_format=3|15
diff --git a/tools/perf/tests/mmap-thread-lookup.c b/tools/perf/tests/mmap-thread-lookup.c
index f94a4196e7c9..2a0068afe3bf 100644
--- a/tools/perf/tests/mmap-thread-lookup.c
+++ b/tools/perf/tests/mmap-thread-lookup.c
@@ -131,7 +131,7 @@ static int synth_all(struct machine *machine)
 {
         return perf_event__synthesize_threads(NULL,
                                               perf_event__process,
-                                              machine, 0, 500);
+                                              machine, 0, 500, 1);
 }
 
 static int synth_process(struct machine *machine)
diff --git a/tools/perf/util/callchain.c b/tools/perf/util/callchain.c
index 510b513e0f01..be09d77cade0 100644
--- a/tools/perf/util/callchain.c
+++ b/tools/perf/util/callchain.c
@@ -65,8 +65,6 @@ static int parse_callchain_mode(const char *value)
                 callchain_param.mode = CHAIN_FOLDED;
                 return 0;
         }
-
-        pr_err("Invalid callchain mode: %s\n", value);
         return -1;
 }
 
@@ -82,8 +80,6 @@ static int parse_callchain_order(const char *value)
                 callchain_param.order_set = true;
                 return 0;
         }
-
-        pr_err("Invalid callchain order: %s\n", value);
         return -1;
 }
 
@@ -105,8 +101,6 @@ static int parse_callchain_sort_key(const char *value)
                 callchain_param.branch_callstack = 1;
                 return 0;
         }
-
-        pr_err("Invalid callchain sort key: %s\n", value);
         return -1;
 }
 
@@ -124,8 +118,6 @@ static int parse_callchain_value(const char *value)
                 callchain_param.value = CCVAL_COUNT;
                 return 0;
         }
-
-        pr_err("Invalid callchain config key: %s\n", value);
         return -1;
 }
 
@@ -319,12 +311,27 @@ int perf_callchain_config(const char *var, const char *value)
 
                 return ret;
         }
-        if (!strcmp(var, "print-type"))
-                return parse_callchain_mode(value);
-        if (!strcmp(var, "order"))
-                return parse_callchain_order(value);
-        if (!strcmp(var, "sort-key"))
-                return parse_callchain_sort_key(value);
+        if (!strcmp(var, "print-type")){
+                int ret;
+                ret = parse_callchain_mode(value);
+                if (ret == -1)
+                        pr_err("Invalid callchain mode: %s\n", value);
+                return ret;
+        }
+        if (!strcmp(var, "order")){
+                int ret;
+                ret = parse_callchain_order(value);
+                if (ret == -1)
+                        pr_err("Invalid callchain order: %s\n", value);
+                return ret;
+        }
+        if (!strcmp(var, "sort-key")){
+                int ret;
+                ret = parse_callchain_sort_key(value);
+                if (ret == -1)
+                        pr_err("Invalid callchain sort key: %s\n", value);
+                return ret;
+        }
         if (!strcmp(var, "threshold")) {
                 callchain_param.min_percent = strtod(value, &endptr);
                 if (value == endptr) {
diff --git a/tools/perf/util/comm.c b/tools/perf/util/comm.c
index 7bc981b6bf29..756a9c14efbb 100644
--- a/tools/perf/util/comm.c
+++ b/tools/perf/util/comm.c
@@ -5,6 +5,7 @@
 #include <stdio.h>
 #include <string.h>
 #include <linux/refcount.h>
+#include "rwsem.h"
 
 struct comm_str {
         char *str;
@@ -14,6 +15,7 @@ struct comm_str {
 
 /* Should perhaps be moved to struct machine */
 static struct rb_root comm_str_root;
+static struct rw_semaphore comm_str_lock = {.lock = PTHREAD_RWLOCK_INITIALIZER,};
 
 static struct comm_str *comm_str__get(struct comm_str *cs)
 {
@@ -25,7 +27,9 @@ static struct comm_str *comm_str__get(struct comm_str *cs)
 static void comm_str__put(struct comm_str *cs)
 {
         if (cs && refcount_dec_and_test(&cs->refcnt)) {
+                down_write(&comm_str_lock);
                 rb_erase(&cs->rb_node, &comm_str_root);
+                up_write(&comm_str_lock);
                 zfree(&cs->str);
                 free(cs);
         }
@@ -50,7 +54,8 @@ static struct comm_str *comm_str__alloc(const char *str)
         return cs;
 }
 
-static struct comm_str *comm_str__findnew(const char *str, struct rb_root *root)
+static
+struct comm_str *__comm_str__findnew(const char *str, struct rb_root *root)
 {
         struct rb_node **p = &root->rb_node;
         struct rb_node *parent = NULL;
@@ -81,6 +86,17 @@ static struct comm_str *comm_str__findnew(const char *str, struct rb_root *root)
         return new;
 }
 
+static struct comm_str *comm_str__findnew(const char *str, struct rb_root *root)
+{
+        struct comm_str *cs;
+
+        down_write(&comm_str_lock);
+        cs = __comm_str__findnew(str, root);
+        up_write(&comm_str_lock);
+
+        return cs;
+}
+
 struct comm *comm__new(const char *str, u64 timestamp, bool exec)
 {
         struct comm *comm = zalloc(sizeof(*comm));
diff --git a/tools/perf/util/event.c b/tools/perf/util/event.c
index 10366b87d0b5..47eff4767edb 100644
--- a/tools/perf/util/event.c
+++ b/tools/perf/util/event.c
@@ -678,23 +678,21 @@ out:
         return err;
 }
 
-int perf_event__synthesize_threads(struct perf_tool *tool,
-                                   perf_event__handler_t process,
-                                   struct machine *machine,
-                                   bool mmap_data,
-                                   unsigned int proc_map_timeout)
+static int __perf_event__synthesize_threads(struct perf_tool *tool,
+                                            perf_event__handler_t process,
+                                            struct machine *machine,
+                                            bool mmap_data,
+                                            unsigned int proc_map_timeout,
+                                            struct dirent **dirent,
+                                            int start,
+                                            int num)
 {
         union perf_event *comm_event, *mmap_event, *fork_event;
         union perf_event *namespaces_event;
-        char proc_path[PATH_MAX];
-        struct dirent **dirent;
         int err = -1;
         char *end;
         pid_t pid;
-        int n, i;
-
-        if (machine__is_default_guest(machine))
-                return 0;
+        int i;
 
         comm_event = malloc(sizeof(comm_event->comm) + machine->id_hdr_size);
         if (comm_event == NULL)
@@ -714,34 +712,25 @@ int perf_event__synthesize_threads(struct perf_tool *tool,
         if (namespaces_event == NULL)
                 goto out_free_fork;
 
-        snprintf(proc_path, sizeof(proc_path), "%s/proc", machine->root_dir);
-        n = scandir(proc_path, &dirent, 0, alphasort);
-
-        if (n < 0)
-                goto out_free_namespaces;
-
-        for (i = 0; i < n; i++) {
+        for (i = start; i < start + num; i++) {
                 if (!isdigit(dirent[i]->d_name[0]))
                         continue;
 
                 pid = (pid_t)strtol(dirent[i]->d_name, &end, 10);
                 /* only interested in proper numerical dirents */
-                if (!*end) {
-                        /*
-                         * We may race with exiting thread, so don't stop just because
-                         * one thread couldn't be synthesized.
-                         */
-                        __event__synthesize_thread(comm_event, mmap_event, fork_event,
-                                                   namespaces_event, pid, 1, process,
-                                                   tool, machine, mmap_data,
-                                                   proc_map_timeout);
-                }
-                free(dirent[i]);
+                if (*end)
+                        continue;
+                /*
+                 * We may race with exiting thread, so don't stop just because
+                 * one thread couldn't be synthesized.
+                 */
+                __event__synthesize_thread(comm_event, mmap_event, fork_event,
+                                           namespaces_event, pid, 1, process,
+                                           tool, machine, mmap_data,
+                                           proc_map_timeout);
         }
-        free(dirent);
         err = 0;
 
-out_free_namespaces:
         free(namespaces_event);
 out_free_fork:
         free(fork_event);
@@ -753,6 +742,118 @@ out:
         return err;
 }
 
+struct synthesize_threads_arg {
+        struct perf_tool *tool;
+        perf_event__handler_t process;
+        struct machine *machine;
+        bool mmap_data;
+        unsigned int proc_map_timeout;
+        struct dirent **dirent;
+        int num;
+        int start;
+};
+
+static void *synthesize_threads_worker(void *arg)
+{
+        struct synthesize_threads_arg *args = arg;
+
+        __perf_event__synthesize_threads(args->tool, args->process,
+                                         args->machine, args->mmap_data,
+                                         args->proc_map_timeout, args->dirent,
+                                         args->start, args->num);
+        return NULL;
+}
+
+int perf_event__synthesize_threads(struct perf_tool *tool,
+                                   perf_event__handler_t process,
+                                   struct machine *machine,
+                                   bool mmap_data,
+                                   unsigned int proc_map_timeout,
+                                   unsigned int nr_threads_synthesize)
+{
+        struct synthesize_threads_arg *args = NULL;
+        pthread_t *synthesize_threads = NULL;
+        char proc_path[PATH_MAX];
+        struct dirent **dirent;
+        int num_per_thread;
+        int m, n, i, j;
+        int thread_nr;
+        int base = 0;
+        int err = -1;
+
+
+        if (machine__is_default_guest(machine))
+                return 0;
+
+        snprintf(proc_path, sizeof(proc_path), "%s/proc", machine->root_dir);
+        n = scandir(proc_path, &dirent, 0, alphasort);
+        if (n < 0)
+                return err;
+
+        if (nr_threads_synthesize == UINT_MAX)
+                thread_nr = sysconf(_SC_NPROCESSORS_ONLN);
+        else
+                thread_nr = nr_threads_synthesize;
+
+        if (thread_nr <= 1) {
+                err = __perf_event__synthesize_threads(tool, process,
+                                                       machine, mmap_data,
+                                                       proc_map_timeout,
+                                                       dirent, base, n);
+                goto free_dirent;
+        }
+        if (thread_nr > n)
+                thread_nr = n;
+
+        synthesize_threads = calloc(sizeof(pthread_t), thread_nr);
+        if (synthesize_threads == NULL)
+                goto free_dirent;
+
+        args = calloc(sizeof(*args), thread_nr);
+        if (args == NULL)
+                goto free_threads;
+
+        num_per_thread = n / thread_nr;
+        m = n % thread_nr;
+        for (i = 0; i < thread_nr; i++) {
+                args[i].tool = tool;
+                args[i].process = process;
+                args[i].machine = machine;
+                args[i].mmap_data = mmap_data;
+                args[i].proc_map_timeout = proc_map_timeout;
+                args[i].dirent = dirent;
+        }
+        for (i = 0; i < m; i++) {
+                args[i].num = num_per_thread + 1;
+                args[i].start = i * args[i].num;
+        }
+        if (i != 0)
+                base = args[i-1].start + args[i-1].num;
+        for (j = i; j < thread_nr; j++) {
+                args[j].num = num_per_thread;
+                args[j].start = base + (j - i) * args[i].num;
+        }
+
+        for (i = 0; i < thread_nr; i++) {
+                if (pthread_create(&synthesize_threads[i], NULL,
+                                   synthesize_threads_worker, &args[i]))
+                        goto out_join;
+        }
+        err = 0;
+out_join:
+        for (i = 0; i < thread_nr; i++)
+                pthread_join(synthesize_threads[i], NULL);
+        free(args);
+free_threads:
+        free(synthesize_threads);
+free_dirent:
+        for (i = 0; i < n; i++)
+                free(dirent[i]);
+        free(dirent);
+
+        return err;
+}
+
 struct process_symbol_args {
         const char *name;
         u64        start;
diff --git a/tools/perf/util/event.h b/tools/perf/util/event.h
index ee7bcc898d35..d6cbb0a0d919 100644
--- a/tools/perf/util/event.h
+++ b/tools/perf/util/event.h
@@ -680,7 +680,8 @@ int perf_event__synthesize_cpu_map(struct perf_tool *tool,
 int perf_event__synthesize_threads(struct perf_tool *tool,
                                    perf_event__handler_t process,
                                    struct machine *machine, bool mmap_data,
-                                   unsigned int proc_map_timeout);
+                                   unsigned int proc_map_timeout,
+                                   unsigned int nr_threads_synthesize);
 int perf_event__synthesize_kernel_mmap(struct perf_tool *tool,
                                        perf_event__handler_t process,
                                        struct machine *machine);
diff --git a/tools/perf/util/evsel.c b/tools/perf/util/evsel.c
index 7389746c0dc4..f894893c203d 100644
--- a/tools/perf/util/evsel.c
+++ b/tools/perf/util/evsel.c
@@ -271,12 +271,17 @@ struct perf_evsel *perf_evsel__new_idx(struct perf_event_attr *attr, int idx)
         return evsel;
 }
 
+static bool perf_event_can_profile_kernel(void)
+{
+        return geteuid() == 0 || perf_event_paranoid() == -1;
+}
+
 struct perf_evsel *perf_evsel__new_cycles(bool precise)
 {
         struct perf_event_attr attr = {
                 .type   = PERF_TYPE_HARDWARE,
                 .config = PERF_COUNT_HW_CPU_CYCLES,
-                .exclude_kernel = geteuid() != 0,
+                .exclude_kernel = !perf_event_can_profile_kernel(),
         };
         struct perf_evsel *evsel;
 
diff --git a/tools/perf/util/machine.c b/tools/perf/util/machine.c
index 585b4a3d64a4..7c3aa479201a 100644
--- a/tools/perf/util/machine.c
+++ b/tools/perf/util/machine.c
@@ -2218,12 +2218,16 @@ int machines__for_each_thread(struct machines *machines,
 int __machine__synthesize_threads(struct machine *machine, struct perf_tool *tool,
                                   struct target *target, struct thread_map *threads,
                                   perf_event__handler_t process, bool data_mmap,
-                                  unsigned int proc_map_timeout)
+                                  unsigned int proc_map_timeout,
+                                  unsigned int nr_threads_synthesize)
 {
         if (target__has_task(target))
                 return perf_event__synthesize_thread_map(tool, threads, process, machine, data_mmap, proc_map_timeout);
         else if (target__has_cpu(target))
-                return perf_event__synthesize_threads(tool, process, machine, data_mmap, proc_map_timeout);
+                return perf_event__synthesize_threads(tool, process,
+                                                      machine, data_mmap,
+                                                      proc_map_timeout,
+                                                      nr_threads_synthesize);
         /* command specified */
         return 0;
 }
diff --git a/tools/perf/util/machine.h b/tools/perf/util/machine.h
index b1cd516f2025..c6a299ea506c 100644
--- a/tools/perf/util/machine.h
+++ b/tools/perf/util/machine.h
@@ -257,15 +257,18 @@ int machines__for_each_thread(struct machines *machines,
 int __machine__synthesize_threads(struct machine *machine, struct perf_tool *tool,
                                   struct target *target, struct thread_map *threads,
                                   perf_event__handler_t process, bool data_mmap,
-                                  unsigned int proc_map_timeout);
+                                  unsigned int proc_map_timeout,
+                                  unsigned int nr_threads_synthesize);
 static inline
 int machine__synthesize_threads(struct machine *machine, struct target *target,
                                 struct thread_map *threads, bool data_mmap,
-                                unsigned int proc_map_timeout)
+                                unsigned int proc_map_timeout,
+                                unsigned int nr_threads_synthesize)
 {
         return __machine__synthesize_threads(machine, NULL, target, threads,
                                              perf_event__process, data_mmap,
-                                             proc_map_timeout);
+                                             proc_map_timeout,
+                                             nr_threads_synthesize);
 }
 
 pid_t machine__get_current_tid(struct machine *machine, int cpu);
diff --git a/tools/perf/util/symbol-elf.c b/tools/perf/util/symbol-elf.c
index 5c39f420111e..9cf781f0d8a2 100644
--- a/tools/perf/util/symbol-elf.c
+++ b/tools/perf/util/symbol-elf.c
@@ -810,12 +810,6 @@ static u64 ref_reloc(struct kmap *kmap)
 void __weak arch__sym_update(struct symbol *s __maybe_unused,
                 GElf_Sym *sym __maybe_unused) { }
 
-void __weak arch__adjust_sym_map_offset(GElf_Sym *sym, GElf_Shdr *shdr,
-                                       struct map *map __maybe_unused)
-{
-        sym->st_value -= shdr->sh_addr - shdr->sh_offset;
-}
-
 int dso__load_sym(struct dso *dso, struct map *map, struct symsrc *syms_ss,
                   struct symsrc *runtime_ss, int kmodule)
 {
@@ -996,7 +990,7 @@ int dso__load_sym(struct dso *dso, struct map *map, struct symsrc *syms_ss,
 
                         /* Adjust symbol to map to file offset */
                         if (adjust_kernel_syms)
-                                arch__adjust_sym_map_offset(&sym, &shdr, map);
+                                sym.st_value -= shdr.sh_addr - shdr.sh_offset;
 
                         if (strcmp(section_name,
                                    (curr_dso->short_name +
diff --git a/tools/perf/util/symbol.h b/tools/perf/util/symbol.h
index 2bd6a1f01a1c..aad99e7e179b 100644
--- a/tools/perf/util/symbol.h
+++ b/tools/perf/util/symbol.h
@@ -344,9 +344,6 @@ int setup_intlist(struct intlist **list, const char *list_str,
 #ifdef HAVE_LIBELF_SUPPORT
 bool elf__needs_adjust_symbols(GElf_Ehdr ehdr);
 void arch__sym_update(struct symbol *s, GElf_Sym *sym);
-void arch__adjust_sym_map_offset(GElf_Sym *sym,
-                                 GElf_Shdr *shdr __maybe_unused,
-                                 struct map *map __maybe_unused);
 #endif
 
 #define SYMBOL_A 0
diff --git a/tools/perf/util/syscalltbl.c b/tools/perf/util/syscalltbl.c
index 19e5db90394c..6eea7cff3d4e 100644
--- a/tools/perf/util/syscalltbl.c
+++ b/tools/perf/util/syscalltbl.c
@@ -15,9 +15,9 @@
 
 #include "syscalltbl.h"
 #include <stdlib.h>
+#include <linux/compiler.h>
 
 #ifdef HAVE_SYSCALL_TABLE
-#include <linux/compiler.h>
 #include <string.h>
 #include "string2.h"
 #include "util.h"
diff --git a/tools/perf/util/thread.c b/tools/perf/util/thread.c
index c09bdb509d82..bf73117b4822 100644
--- a/tools/perf/util/thread.c
+++ b/tools/perf/util/thread.c
@@ -45,6 +45,8 @@ struct thread *thread__new(pid_t pid, pid_t tid)
                 thread->cpu = -1;
                 INIT_LIST_HEAD(&thread->namespaces_list);
                 INIT_LIST_HEAD(&thread->comm_list);
+                init_rwsem(&thread->namespaces_lock);
+                init_rwsem(&thread->comm_lock);
 
                 comm_str = malloc(32);
                 if (!comm_str)
@@ -83,18 +85,26 @@ void thread__delete(struct thread *thread)
                 map_groups__put(thread->mg);
                 thread->mg = NULL;
         }
+        down_write(&thread->namespaces_lock);
         list_for_each_entry_safe(namespaces, tmp_namespaces,
                                  &thread->namespaces_list, list) {
                 list_del(&namespaces->list);
                 namespaces__free(namespaces);
         }
+        up_write(&thread->namespaces_lock);
+
+        down_write(&thread->comm_lock);
         list_for_each_entry_safe(comm, tmp_comm, &thread->comm_list, list) {
                 list_del(&comm->list);
                 comm__free(comm);
         }
+        up_write(&thread->comm_lock);
+
         unwind__finish_access(thread);
         nsinfo__zput(thread->nsinfo);
 
+        exit_rwsem(&thread->namespaces_lock);
+        exit_rwsem(&thread->comm_lock);
         free(thread);
 }
 
@@ -125,8 +135,8 @@ struct namespaces *thread__namespaces(const struct thread *thread)
         return list_first_entry(&thread->namespaces_list, struct namespaces, list);
 }
 
-int thread__set_namespaces(struct thread *thread, u64 timestamp,
-                           struct namespaces_event *event)
+static int __thread__set_namespaces(struct thread *thread, u64 timestamp,
+                                    struct namespaces_event *event)
 {
         struct namespaces *new, *curr = thread__namespaces(thread);
 
@@ -149,6 +159,17 @@ int thread__set_namespaces(struct thread *thread, u64 timestamp,
         return 0;
 }
 
+int thread__set_namespaces(struct thread *thread, u64 timestamp,
+                           struct namespaces_event *event)
+{
+        int ret;
+
+        down_write(&thread->namespaces_lock);
+        ret = __thread__set_namespaces(thread, timestamp, event);
+        up_write(&thread->namespaces_lock);
+        return ret;
+}
+
 struct comm *thread__comm(const struct thread *thread)
 {
         if (list_empty(&thread->comm_list))
@@ -170,8 +191,8 @@ struct comm *thread__exec_comm(const struct thread *thread)
         return last;
 }
 
-int __thread__set_comm(struct thread *thread, const char *str, u64 timestamp,
-                       bool exec)
+static int ____thread__set_comm(struct thread *thread, const char *str,
+                                u64 timestamp, bool exec)
 {
         struct comm *new, *curr = thread__comm(thread);
 
@@ -195,6 +216,17 @@ int __thread__set_comm(struct thread *thread, const char *str, u64 timestamp,
         return 0;
 }
 
+int __thread__set_comm(struct thread *thread, const char *str, u64 timestamp,
+                       bool exec)
+{
+        int ret;
+
+        down_write(&thread->comm_lock);
+        ret = ____thread__set_comm(thread, str, timestamp, exec);
+        up_write(&thread->comm_lock);
+        return ret;
+}
+
 int thread__set_comm_from_proc(struct thread *thread)
 {
         char path[64];
@@ -212,7 +244,7 @@ int thread__set_comm_from_proc(struct thread *thread)
         return err;
 }
 
-const char *thread__comm_str(const struct thread *thread)
+static const char *__thread__comm_str(const struct thread *thread)
 {
         const struct comm *comm = thread__comm(thread);
 
@@ -222,6 +254,17 @@ const char *thread__comm_str(const struct thread *thread)
         return comm__str(comm);
 }
 
+const char *thread__comm_str(const struct thread *thread)
+{
+        const char *str;
+
+        down_read((struct rw_semaphore *)&thread->comm_lock);
+        str = __thread__comm_str(thread);
+        up_read((struct rw_semaphore *)&thread->comm_lock);
+
+        return str;
+}
+
 /* CHECKME: it should probably better return the max comm len from its comm list */
 int thread__comm_len(struct thread *thread)
 {
diff --git a/tools/perf/util/thread.h b/tools/perf/util/thread.h
index cb1a5dd5c2b9..10555d6a0b86 100644
--- a/tools/perf/util/thread.h
+++ b/tools/perf/util/thread.h
@@ -9,6 +9,7 @@
 #include "symbol.h"
 #include <strlist.h>
 #include <intlist.h>
+#include "rwsem.h"
 
 struct thread_stack;
 struct unwind_libunwind_ops;
@@ -29,7 +30,9 @@ struct thread {
         int                     comm_len;
         bool                    dead; /* if set thread has exited */
         struct list_head        namespaces_list;
+        struct rw_semaphore     namespaces_lock;
         struct list_head        comm_list;
+        struct rw_semaphore     comm_lock;
         u64                     db_id;
 
         void                    *priv;
diff --git a/tools/perf/util/top.h b/tools/perf/util/top.h
index 9bdfb78a9a35..f4296e1e3bb8 100644
--- a/tools/perf/util/top.h
+++ b/tools/perf/util/top.h
@@ -37,6 +37,7 @@ struct perf_top {
         int                sym_pcnt_filter;
         const char         *sym_filter;
         float              min_percent;
+        unsigned int       nr_threads_synthesize;
 };
 
 #define CONSOLE_CLEAR ""