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

Fixes for perf/core:

 - Rename some perf_target methods to avoid double negation, from Namhyung Kim.
 - Revert change to use per task events with inheritance, from Namhyung Kim.
 - Events should start disabled till children starts running, from David Ahern.

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

17 files changed, 208 insertions, 97 deletions

diff --git a/tools/perf/Makefile b/tools/perf/Makefile
index 4734f41f801d..398094c3d3c9 100644
--- a/tools/perf/Makefile
+++ b/tools/perf/Makefile
@@ -201,8 +201,8 @@ endif
 
 export PERL_PATH
 
-FLEX = $(CROSS_COMPILE)flex
-BISON= $(CROSS_COMPILE)bison
+FLEX = flex
+BISON= bison
 
 $(OUTPUT)util/parse-events-flex.c: util/parse-events.l
         $(QUIET_FLEX)$(FLEX) --header-file=$(OUTPUT)util/parse-events-flex.h -t util/parse-events.l > $(OUTPUT)util/parse-events-flex.c
@@ -737,10 +737,10 @@ $(OUTPUT)perf.o perf.spec \
 # over the general rule for .o
 
 $(OUTPUT)util/%-flex.o: $(OUTPUT)util/%-flex.c $(OUTPUT)PERF-CFLAGS
-        $(QUIET_CC)$(CC) -o $@ -c $(ALL_CFLAGS) -Iutil/ -Wno-redundant-decls -Wno-switch-default -Wno-unused-function $<
+        $(QUIET_CC)$(CC) -o $@ -c $(ALL_CFLAGS) -Iutil/ -w $<
 
 $(OUTPUT)util/%-bison.o: $(OUTPUT)util/%-bison.c $(OUTPUT)PERF-CFLAGS
-        $(QUIET_CC)$(CC) -o $@ -c $(ALL_CFLAGS) -DYYENABLE_NLS=0 -DYYLTYPE_IS_TRIVIAL=0 -Iutil/ -Wno-redundant-decls -Wno-switch-default -Wno-unused-function $<
+        $(QUIET_CC)$(CC) -o $@ -c $(ALL_CFLAGS) -DYYENABLE_NLS=0 -DYYLTYPE_IS_TRIVIAL=0 -Iutil/ -w $<
 
 $(OUTPUT)%.o: %.c $(OUTPUT)PERF-CFLAGS
         $(QUIET_CC)$(CC) -o $@ -c $(ALL_CFLAGS) $<
diff --git a/tools/perf/builtin-record.c b/tools/perf/builtin-record.c
index d19058a7b84c..8a3dfac161e2 100644
--- a/tools/perf/builtin-record.c
+++ b/tools/perf/builtin-record.c
@@ -754,6 +754,9 @@ static struct perf_record record = {
                 .user_freq           = UINT_MAX,
                 .user_interval       = ULLONG_MAX,
                 .freq                = 1000,
+                .target              = {
+                        .uses_mmap   = true,
+                },
         },
         .write_mode = WRITE_FORCE,
         .file_new   = true,
diff --git a/tools/perf/builtin-report.c b/tools/perf/builtin-report.c
index 74776558ddfb..d58e41445d0d 100644
--- a/tools/perf/builtin-report.c
+++ b/tools/perf/builtin-report.c
@@ -377,16 +377,23 @@ static int __cmd_report(struct perf_report *rep)
             (kernel_map->dso->hit &&
              (kernel_kmap->ref_reloc_sym == NULL ||
               kernel_kmap->ref_reloc_sym->addr == 0))) {
-                const struct dso *kdso = kernel_map->dso;
+                const char *desc =
+                    "As no suitable kallsyms nor vmlinux was found, kernel samples\n"
+                    "can't be resolved.";
+
+                if (kernel_map) {
+                        const struct dso *kdso = kernel_map->dso;
+                        if (!RB_EMPTY_ROOT(&kdso->symbols[MAP__FUNCTION])) {
+                                desc = "If some relocation was applied (e.g. "
+                                       "kexec) symbols may be misresolved.";
+                        }
+                }
 
                 ui__warning(
 "Kernel address maps (/proc/{kallsyms,modules}) were restricted.\n\n"
 "Check /proc/sys/kernel/kptr_restrict before running 'perf record'.\n\n%s\n\n"
 "Samples in kernel modules can't be resolved as well.\n\n",
-                            RB_EMPTY_ROOT(&kdso->symbols[MAP__FUNCTION]) ?
-"As no suitable kallsyms nor vmlinux was found, kernel samples\n"
-"can't be resolved." :
-"If some relocation was applied (e.g. kexec) symbols may be misresolved.");
+                desc);
         }
 
         if (dump_trace) {
diff --git a/tools/perf/builtin-stat.c b/tools/perf/builtin-stat.c
index d0605689bad9..62ae30d34fa6 100644
--- a/tools/perf/builtin-stat.c
+++ b/tools/perf/builtin-stat.c
@@ -282,6 +282,8 @@ static int create_perf_stat_counter(struct perf_evsel *evsel,
 {
         struct perf_event_attr *attr = &evsel->attr;
         struct xyarray *group_fd = NULL;
+        bool exclude_guest_missing = false;
+        int ret;
 
         if (group && evsel != first)
                 group_fd = first->fd;
@@ -292,16 +294,39 @@ static int create_perf_stat_counter(struct perf_evsel *evsel,
 
         attr->inherit = !no_inherit;
 
-        if (!perf_target__no_cpu(&target))
-                return perf_evsel__open_per_cpu(evsel, evsel_list->cpus,
-                                                group, group_fd);
-        if (perf_target__no_task(&target) && (!group || evsel == first)) {
+retry:
+        if (exclude_guest_missing)
+                evsel->attr.exclude_guest = evsel->attr.exclude_host = 0;
+
+        if (perf_target__has_cpu(&target)) {
+                ret = perf_evsel__open_per_cpu(evsel, evsel_list->cpus,
+                                               group, group_fd);
+                if (ret)
+                        goto check_ret;
+                return 0;
+        }
+
+        if (!perf_target__has_task(&target) && (!group || evsel == first)) {
                 attr->disabled = 1;
                 attr->enable_on_exec = 1;
         }
 
-        return perf_evsel__open_per_thread(evsel, evsel_list->threads,
-                                           group, group_fd);
+        ret = perf_evsel__open_per_thread(evsel, evsel_list->threads,
+                                          group, group_fd);
+        if (!ret)
+                return 0;
+        /* fall through */
+check_ret:
+        if (ret && errno == EINVAL) {
+                if (!exclude_guest_missing &&
+                    (evsel->attr.exclude_guest || evsel->attr.exclude_host)) {
+                        pr_debug("Old kernel, cannot exclude "
+                                 "guest or host samples.\n");
+                        exclude_guest_missing = true;
+                        goto retry;
+                }
+        }
+        return ret;
 }
 
 /*
@@ -972,7 +997,7 @@ static void print_stat(int argc, const char **argv)
         if (!csv_output) {
                 fprintf(output, "\n");
                 fprintf(output, " Performance counter stats for ");
-                if (perf_target__no_task(&target)) {
+                if (!perf_target__has_task(&target)) {
                         fprintf(output, "\'%s", argv[0]);
                         for (i = 1; i < argc; i++)
                                 fprintf(output, " %s", argv[i]);
@@ -1194,13 +1219,13 @@ int cmd_stat(int argc, const char **argv, const char *prefix __used)
         } else if (big_num_opt == 0) /* User passed --no-big-num */
                 big_num = false;
 
-        if (!argc && perf_target__no_task(&target))
+        if (!argc && !perf_target__has_task(&target))
                 usage_with_options(stat_usage, options);
         if (run_count <= 0)
                 usage_with_options(stat_usage, options);
 
         /* no_aggr, cgroup are for system-wide only */
-        if ((no_aggr || nr_cgroups) && perf_target__no_cpu(&target)) {
+        if ((no_aggr || nr_cgroups) && !perf_target__has_cpu(&target)) {
                 fprintf(stderr, "both cgroup and no-aggregation "
                         "modes only available in system-wide mode\n");
 
@@ -1213,9 +1238,9 @@ int cmd_stat(int argc, const char **argv, const char *prefix __used)
         perf_target__validate(&target);
 
         if (perf_evlist__create_maps(evsel_list, &target) < 0) {
-                if (!perf_target__no_task(&target))
+                if (perf_target__has_task(&target))
                         pr_err("Problems finding threads of monitor\n");
-                if (!perf_target__no_cpu(&target))
+                if (perf_target__has_cpu(&target))
                         perror("failed to parse CPUs map");
 
                 usage_with_options(stat_usage, options);
diff --git a/tools/perf/builtin-test.c b/tools/perf/builtin-test.c
index 9d9abbbe23be..6c47376e29d8 100644
--- a/tools/perf/builtin-test.c
+++ b/tools/perf/builtin-test.c
@@ -851,6 +851,28 @@ static int test__checkevent_symbolic_name_modifier(struct perf_evlist *evlist)
         return test__checkevent_symbolic_name(evlist);
 }
 
+static int test__checkevent_exclude_host_modifier(struct perf_evlist *evlist)
+{
+        struct perf_evsel *evsel = list_entry(evlist->entries.next,
+                                              struct perf_evsel, node);
+
+        TEST_ASSERT_VAL("wrong exclude guest", !evsel->attr.exclude_guest);
+        TEST_ASSERT_VAL("wrong exclude host", evsel->attr.exclude_host);
+
+        return test__checkevent_symbolic_name(evlist);
+}
+
+static int test__checkevent_exclude_guest_modifier(struct perf_evlist *evlist)
+{
+        struct perf_evsel *evsel = list_entry(evlist->entries.next,
+                                              struct perf_evsel, node);
+
+        TEST_ASSERT_VAL("wrong exclude guest", evsel->attr.exclude_guest);
+        TEST_ASSERT_VAL("wrong exclude host", !evsel->attr.exclude_host);
+
+        return test__checkevent_symbolic_name(evlist);
+}
+
 static int test__checkevent_symbolic_alias_modifier(struct perf_evlist *evlist)
 {
         struct perf_evsel *evsel = list_entry(evlist->entries.next,
@@ -1091,6 +1113,14 @@ static struct test__event_st {
                 .name  = "r1,syscalls:sys_enter_open:k,1:1:hp",
                 .check = test__checkevent_list,
         },
+        {
+                .name  = "instructions:G",
+                .check = test__checkevent_exclude_host_modifier,
+        },
+        {
+                .name  = "instructions:H",
+                .check = test__checkevent_exclude_guest_modifier,
+        },
 };
 
 #define TEST__EVENTS_CNT (sizeof(test__events) / sizeof(struct test__event_st))
@@ -1167,6 +1197,7 @@ static int test__PERF_RECORD(void)
         struct perf_record_opts opts = {
                 .target = {
                         .uid = UINT_MAX,
+                        .uses_mmap = true,
                 },
                 .no_delay   = true,
                 .freq       = 10,
diff --git a/tools/perf/builtin-top.c b/tools/perf/builtin-top.c
index 4eb6171e143b..3e981a710c4d 100644
--- a/tools/perf/builtin-top.c
+++ b/tools/perf/builtin-top.c
@@ -1020,7 +1020,7 @@ static int __cmd_top(struct perf_top *top)
         if (ret)
                 goto out_delete;
 
-        if (!perf_target__no_task(&top->target))
+        if (perf_target__has_task(&top->target))
                 perf_event__synthesize_thread_map(&top->tool, top->evlist->threads,
                                                   perf_event__process,
                                                   &top->session->host_machine);
@@ -1162,6 +1162,9 @@ int cmd_top(int argc, const char **argv, const char *prefix __used)
                 .freq                = 1000, /* 1 KHz */
                 .mmap_pages          = 128,
                 .sym_pcnt_filter     = 5,
+                .target              = {
+                        .uses_mmap   = true,
+                },
         };
         char callchain_default_opt[] = "fractal,0.5,callee";
         const struct option options[] = {
diff --git a/tools/perf/util/evlist.c b/tools/perf/util/evlist.c
index 1201daf71719..4ac5f5ae4ce9 100644
--- a/tools/perf/util/evlist.c
+++ b/tools/perf/util/evlist.c
@@ -609,10 +609,12 @@ int perf_evlist__create_maps(struct perf_evlist *evlist,
         if (evlist->threads == NULL)
                 return -1;
 
-        if (!perf_target__no_cpu(target))
-                evlist->cpus = cpu_map__new(target->cpu_list);
-        else
+        if (perf_target__has_task(target))
+                evlist->cpus = cpu_map__dummy_new();
+        else if (!perf_target__has_cpu(target) && !target->uses_mmap)
                 evlist->cpus = cpu_map__dummy_new();
+        else
+                evlist->cpus = cpu_map__new(target->cpu_list);
 
         if (evlist->cpus == NULL)
                 goto out_delete_threads;
diff --git a/tools/perf/util/evsel.c b/tools/perf/util/evsel.c
index 21eaab240396..f4f427ce4d64 100644
--- a/tools/perf/util/evsel.c
+++ b/tools/perf/util/evsel.c
@@ -70,6 +70,7 @@ void perf_evsel__config(struct perf_evsel *evsel, struct perf_record_opts *opts,
         struct perf_event_attr *attr = &evsel->attr;
         int track = !evsel->idx; /* only the first counter needs these */
 
+        attr->disabled = 1;
         attr->sample_id_all = opts->sample_id_all_missing ? 0 : 1;
         attr->inherit       = !opts->no_inherit;
         attr->read_format   = PERF_FORMAT_TOTAL_TIME_ENABLED |
@@ -115,7 +116,7 @@ void perf_evsel__config(struct perf_evsel *evsel, struct perf_record_opts *opts,
 
         if (!opts->sample_id_all_missing &&
             (opts->sample_time || !opts->no_inherit ||
-             !perf_target__no_cpu(&opts->target)))
+             perf_target__has_cpu(&opts->target)))
                 attr->sample_type       |= PERF_SAMPLE_TIME;
 
         if (opts->raw_samples) {
@@ -138,7 +139,6 @@ void perf_evsel__config(struct perf_evsel *evsel, struct perf_record_opts *opts,
 
         if (perf_target__none(&opts->target) &&
             (!opts->group || evsel == first)) {
-                attr->disabled = 1;
                 attr->enable_on_exec = 1;
         }
 }
diff --git a/tools/perf/util/header.c b/tools/perf/util/header.c
index 6e618ba21382..538598012139 100644
--- a/tools/perf/util/header.c
+++ b/tools/perf/util/header.c
@@ -291,7 +291,7 @@ int build_id_cache__add_s(const char *sbuild_id, const char *debugdir,
         if (mkdir_p(filename, 0755))
                 goto out_free;
 
-        snprintf(filename + len, sizeof(filename) - len, "/%s", sbuild_id);
+        snprintf(filename + len, size - len, "/%s", sbuild_id);
 
         if (access(filename, F_OK)) {
                 if (is_kallsyms) {
diff --git a/tools/perf/util/hist.c b/tools/perf/util/hist.c
index 9f6d630d5316..1293b5ebea4d 100644
--- a/tools/perf/util/hist.c
+++ b/tools/perf/util/hist.c
@@ -599,7 +599,7 @@ static size_t ipchain__fprintf_graph(FILE *fp, struct callchain_list *chain,
         if (chain->ms.sym)
                 ret += fprintf(fp, "%s\n", chain->ms.sym->name);
         else
-                ret += fprintf(fp, "%p\n", (void *)(long)chain->ip);
+                ret += fprintf(fp, "0x%0" PRIx64 "\n", chain->ip);
 
         return ret;
 }
diff --git a/tools/perf/util/parse-events.c b/tools/perf/util/parse-events.c
index 5b3a0ef4e232..c7fc18a33d54 100644
--- a/tools/perf/util/parse-events.c
+++ b/tools/perf/util/parse-events.c
@@ -593,17 +593,27 @@ int parse_events_add_breakpoint(struct list_head *list, int *idx,
 static int config_term(struct perf_event_attr *attr,
                        struct parse_events__term *term)
 {
-        switch (term->type) {
+#define CHECK_TYPE_VAL(type)                                    \
+do {                                                            \
+        if (PARSE_EVENTS__TERM_TYPE_ ## type != term->type_val) \
+                return -EINVAL;                                 \
+} while (0)
+
+        switch (term->type_term) {
         case PARSE_EVENTS__TERM_TYPE_CONFIG:
+                CHECK_TYPE_VAL(NUM);
                 attr->config = term->val.num;
                 break;
         case PARSE_EVENTS__TERM_TYPE_CONFIG1:
+                CHECK_TYPE_VAL(NUM);
                 attr->config1 = term->val.num;
                 break;
         case PARSE_EVENTS__TERM_TYPE_CONFIG2:
+                CHECK_TYPE_VAL(NUM);
                 attr->config2 = term->val.num;
                 break;
         case PARSE_EVENTS__TERM_TYPE_SAMPLE_PERIOD:
+                CHECK_TYPE_VAL(NUM);
                 attr->sample_period = term->val.num;
                 break;
         case PARSE_EVENTS__TERM_TYPE_BRANCH_SAMPLE_TYPE:
@@ -615,7 +625,9 @@ static int config_term(struct perf_event_attr *attr,
         default:
                 return -EINVAL;
         }
+
         return 0;
+#undef CHECK_TYPE_VAL
 }
 
 static int config_attr(struct perf_event_attr *attr,
@@ -1015,11 +1027,12 @@ void print_events(const char *event_glob)
 
 int parse_events__is_hardcoded_term(struct parse_events__term *term)
 {
-        return term->type <= PARSE_EVENTS__TERM_TYPE_HARDCODED_MAX;
+        return term->type_term != PARSE_EVENTS__TERM_TYPE_USER;
 }
 
-int parse_events__new_term(struct parse_events__term **_term, int type,
-                           char *config, char *str, long num)
+static int new_term(struct parse_events__term **_term, int type_val,
+                    int type_term, char *config,
+                    char *str, long num)
 {
         struct parse_events__term *term;
 
@@ -1028,15 +1041,11 @@ int parse_events__new_term(struct parse_events__term **_term, int type,
                 return -ENOMEM;
 
         INIT_LIST_HEAD(&term->list);
-        term->type = type;
+        term->type_val  = type_val;
+        term->type_term = type_term;
         term->config = config;
 
-        switch (type) {
-        case PARSE_EVENTS__TERM_TYPE_CONFIG:
-        case PARSE_EVENTS__TERM_TYPE_CONFIG1:
-        case PARSE_EVENTS__TERM_TYPE_CONFIG2:
-        case PARSE_EVENTS__TERM_TYPE_SAMPLE_PERIOD:
-        case PARSE_EVENTS__TERM_TYPE_BRANCH_SAMPLE_TYPE:
+        switch (type_val) {
         case PARSE_EVENTS__TERM_TYPE_NUM:
                 term->val.num = num;
                 break;
@@ -1051,6 +1060,20 @@ int parse_events__new_term(struct parse_events__term **_term, int type,
         return 0;
 }
 
+int parse_events__term_num(struct parse_events__term **term,
+                           int type_term, char *config, long num)
+{
+        return new_term(term, PARSE_EVENTS__TERM_TYPE_NUM, type_term,
+                        config, NULL, num);
+}
+
+int parse_events__term_str(struct parse_events__term **term,
+                           int type_term, char *config, char *str)
+{
+        return new_term(term, PARSE_EVENTS__TERM_TYPE_STR, type_term,
+                        config, str, 0);
+}
+
 void parse_events__free_terms(struct list_head *terms)
 {
         struct parse_events__term *term, *h;
diff --git a/tools/perf/util/parse-events.h b/tools/perf/util/parse-events.h
index 5cb002894a17..3fddd610d350 100644
--- a/tools/perf/util/parse-events.h
+++ b/tools/perf/util/parse-events.h
@@ -36,16 +36,17 @@ extern int parse_filter(const struct option *opt, const char *str, int unset);
 #define EVENTS_HELP_MAX (128*1024)
 
 enum {
+        PARSE_EVENTS__TERM_TYPE_NUM,
+        PARSE_EVENTS__TERM_TYPE_STR,
+};
+
+enum {
+        PARSE_EVENTS__TERM_TYPE_USER,
         PARSE_EVENTS__TERM_TYPE_CONFIG,
         PARSE_EVENTS__TERM_TYPE_CONFIG1,
         PARSE_EVENTS__TERM_TYPE_CONFIG2,
         PARSE_EVENTS__TERM_TYPE_SAMPLE_PERIOD,
         PARSE_EVENTS__TERM_TYPE_BRANCH_SAMPLE_TYPE,
-        PARSE_EVENTS__TERM_TYPE_NUM,
-        PARSE_EVENTS__TERM_TYPE_STR,
-
-        PARSE_EVENTS__TERM_TYPE_HARDCODED_MAX =
-                PARSE_EVENTS__TERM_TYPE_BRANCH_SAMPLE_TYPE,
 };
 
 struct parse_events__term {
@@ -54,14 +55,16 @@ struct parse_events__term {
                 char *str;
                 long  num;
         } val;
-        int type;
-
+        int type_val;
+        int type_term;
         struct list_head list;
 };
 
 int parse_events__is_hardcoded_term(struct parse_events__term *term);
-int parse_events__new_term(struct parse_events__term **term, int type,
-                           char *config, char *str, long num);
+int parse_events__term_num(struct parse_events__term **_term,
+                           int type_term, char *config, long num);
+int parse_events__term_str(struct parse_events__term **_term,
+                           int type_term, char *config, char *str);
 void parse_events__free_terms(struct list_head *terms);
 int parse_events_modifier(struct list_head *list __used, char *str __used);
 int parse_events_add_tracepoint(struct list_head *list, int *idx,
diff --git a/tools/perf/util/parse-events.l b/tools/perf/util/parse-events.l
index 05d766e3ecb5..1fcf1bbc5458 100644
--- a/tools/perf/util/parse-events.l
+++ b/tools/perf/util/parse-events.l
@@ -54,7 +54,7 @@ num_dec		[0-9]+
 num_hex         0x[a-fA-F0-9]+
 num_raw_hex     [a-fA-F0-9]+
 name            [a-zA-Z_*?][a-zA-Z0-9_*?]*
-modifier_event  [ukhp]{1,5}
+modifier_event  [ukhpGH]{1,8}
 modifier_bp     [rwx]
 
 %%
diff --git a/tools/perf/util/parse-events.y b/tools/perf/util/parse-events.y
index d9637da7333c..936913ea0ab6 100644
--- a/tools/perf/util/parse-events.y
+++ b/tools/perf/util/parse-events.y
@@ -176,8 +176,8 @@ PE_NAME '=' PE_NAME
 {
         struct parse_events__term *term;
 
-        ABORT_ON(parse_events__new_term(&term, PARSE_EVENTS__TERM_TYPE_STR,
-                 $1, $3, 0));
+        ABORT_ON(parse_events__term_str(&term, PARSE_EVENTS__TERM_TYPE_USER,
+                                        $1, $3));
         $$ = term;
 }
 |
@@ -185,8 +185,8 @@ PE_NAME '=' PE_VALUE
 {
         struct parse_events__term *term;
 
-        ABORT_ON(parse_events__new_term(&term, PARSE_EVENTS__TERM_TYPE_NUM,
-                 $1, NULL, $3));
+        ABORT_ON(parse_events__term_num(&term, PARSE_EVENTS__TERM_TYPE_USER,
+                                        $1, $3));
         $$ = term;
 }
 |
@@ -194,8 +194,8 @@ PE_NAME
 {
         struct parse_events__term *term;
 
-        ABORT_ON(parse_events__new_term(&term, PARSE_EVENTS__TERM_TYPE_NUM,
-                 $1, NULL, 1));
+        ABORT_ON(parse_events__term_num(&term, PARSE_EVENTS__TERM_TYPE_USER,
+                                        $1, 1));
         $$ = term;
 }
 |
@@ -203,7 +203,7 @@ PE_TERM '=' PE_VALUE
 {
         struct parse_events__term *term;
 
-        ABORT_ON(parse_events__new_term(&term, $1, NULL, NULL, $3));
+        ABORT_ON(parse_events__term_num(&term, $1, NULL, $3));
         $$ = term;
 }
 |
@@ -211,7 +211,7 @@ PE_TERM
 {
         struct parse_events__term *term;
 
-        ABORT_ON(parse_events__new_term(&term, $1, NULL, NULL, 1));
+        ABORT_ON(parse_events__term_num(&term, $1, NULL, 1));
         $$ = term;
 }
 
diff --git a/tools/perf/util/pmu.c b/tools/perf/util/pmu.c
index cb08a118e811..8ee219b7285b 100644
--- a/tools/perf/util/pmu.c
+++ b/tools/perf/util/pmu.c
@@ -225,7 +225,7 @@ static int pmu_config_term(struct list_head *formats,
         if (parse_events__is_hardcoded_term(term))
                 return 0;
 
-        if (term->type != PARSE_EVENTS__TERM_TYPE_NUM)
+        if (term->type_val != PARSE_EVENTS__TERM_TYPE_NUM)
                 return -EINVAL;
 
         format = pmu_find_format(formats, term->config);
@@ -246,6 +246,11 @@ static int pmu_config_term(struct list_head *formats,
                 return -EINVAL;
         }
 
+        /*
+         * XXX If we ever decide to go with string values for
+         * non-hardcoded terms, here's the place to translate
+         * them into value.
+         */
         *vp |= pmu_format_value(format->bits, term->val.num);
         return 0;
 }
@@ -324,49 +329,58 @@ static struct test_format {
 /* Simulated users input. */
 static struct parse_events__term test_terms[] = {
         {
-                .config  = (char *) "krava01",
-                .val.num = 15,
-                .type    = PARSE_EVENTS__TERM_TYPE_NUM,
+                .config    = (char *) "krava01",
+                .val.num   = 15,
+                .type_val  = PARSE_EVENTS__TERM_TYPE_NUM,
+                .type_term = PARSE_EVENTS__TERM_TYPE_USER,
         },
         {
-                .config  = (char *) "krava02",
-                .val.num = 170,
-                .type    = PARSE_EVENTS__TERM_TYPE_NUM,
+                .config    = (char *) "krava02",
+                .val.num   = 170,
+                .type_val  = PARSE_EVENTS__TERM_TYPE_NUM,
+                .type_term = PARSE_EVENTS__TERM_TYPE_USER,
         },
         {
-                .config  = (char *) "krava03",
-                .val.num = 1,
-                .type    = PARSE_EVENTS__TERM_TYPE_NUM,
+                .config    = (char *) "krava03",
+                .val.num   = 1,
+                .type_val  = PARSE_EVENTS__TERM_TYPE_NUM,
+                .type_term = PARSE_EVENTS__TERM_TYPE_USER,
         },
         {
-                .config  = (char *) "krava11",
-                .val.num = 27,
-                .type    = PARSE_EVENTS__TERM_TYPE_NUM,
+                .config    = (char *) "krava11",
+                .val.num   = 27,
+                .type_val  = PARSE_EVENTS__TERM_TYPE_NUM,
+                .type_term = PARSE_EVENTS__TERM_TYPE_USER,
         },
         {
-                .config  = (char *) "krava12",
-                .val.num = 1,
-                .type    = PARSE_EVENTS__TERM_TYPE_NUM,
+                .config    = (char *) "krava12",
+                .val.num   = 1,
+                .type_val  = PARSE_EVENTS__TERM_TYPE_NUM,
+                .type_term = PARSE_EVENTS__TERM_TYPE_USER,
         },
         {
-                .config  = (char *) "krava13",
-                .val.num = 2,
-                .type    = PARSE_EVENTS__TERM_TYPE_NUM,
+                .config    = (char *) "krava13",
+                .val.num   = 2,
+                .type_val  = PARSE_EVENTS__TERM_TYPE_NUM,
+                .type_term = PARSE_EVENTS__TERM_TYPE_USER,
         },
         {
-                .config  = (char *) "krava21",
-                .val.num = 119,
-                .type    = PARSE_EVENTS__TERM_TYPE_NUM,
+                .config    = (char *) "krava21",
+                .val.num   = 119,
+                .type_val  = PARSE_EVENTS__TERM_TYPE_NUM,
+                .type_term = PARSE_EVENTS__TERM_TYPE_USER,
         },
         {
-                .config  = (char *) "krava22",
-                .val.num = 11,
-                .type    = PARSE_EVENTS__TERM_TYPE_NUM,
+                .config    = (char *) "krava22",
+                .val.num   = 11,
+                .type_val  = PARSE_EVENTS__TERM_TYPE_NUM,
+                .type_term = PARSE_EVENTS__TERM_TYPE_USER,
         },
         {
-                .config  = (char *) "krava23",
-                .val.num = 2,
-                .type    = PARSE_EVENTS__TERM_TYPE_NUM,
+                .config    = (char *) "krava23",
+                .val.num   = 2,
+                .type_val  = PARSE_EVENTS__TERM_TYPE_NUM,
+                .type_term = PARSE_EVENTS__TERM_TYPE_USER,
         },
 };
 #define TERMS_CNT (sizeof(test_terms) / sizeof(struct parse_events__term))
diff --git a/tools/perf/util/symbol.c b/tools/perf/util/symbol.c
index c0a028c3ebaf..ab9867b2b433 100644
--- a/tools/perf/util/symbol.c
+++ b/tools/perf/util/symbol.c
@@ -977,8 +977,9 @@ static Elf_Scn *elf_section_by_name(Elf *elf, GElf_Ehdr *ep,
  * And always look at the original dso, not at debuginfo packages, that
  * have the PLT data stripped out (shdr_rel_plt.sh_type == SHT_NOBITS).
  */
-static int dso__synthesize_plt_symbols(struct  dso *dso, struct map *map,
-                                       symbol_filter_t filter)
+static int
+dso__synthesize_plt_symbols(struct dso *dso, char *name, struct map *map,
+                            symbol_filter_t filter)
 {
         uint32_t nr_rel_entries, idx;
         GElf_Sym sym;
@@ -993,10 +994,7 @@ static int dso__synthesize_plt_symbols(struct  dso *dso, struct map *map,
         char sympltname[1024];
         Elf *elf;
         int nr = 0, symidx, fd, err = 0;
-        char name[PATH_MAX];
 
-        snprintf(name, sizeof(name), "%s%s",
-                 symbol_conf.symfs, dso->long_name);
         fd = open(name, O_RDONLY);
         if (fd < 0)
                 goto out;
@@ -1703,8 +1701,9 @@ restart:
                         continue;
 
                 if (ret > 0) {
-                        int nr_plt = dso__synthesize_plt_symbols(dso, map,
-                                                                 filter);
+                        int nr_plt;
+
+                        nr_plt = dso__synthesize_plt_symbols(dso, name, map, filter);
                         if (nr_plt > 0)
                                 ret += nr_plt;
                         break;
diff --git a/tools/perf/util/target.h b/tools/perf/util/target.h
index 127cff3f8ced..a4be8575fda5 100644
--- a/tools/perf/util/target.h
+++ b/tools/perf/util/target.h
@@ -11,6 +11,7 @@ struct perf_target {
         const char   *uid_str;
         uid_t        uid;
         bool         system_wide;
+        bool         uses_mmap;
 };
 
 enum perf_target_errno {
@@ -46,19 +47,19 @@ enum perf_target_errno perf_target__parse_uid(struct perf_target *target);
 int perf_target__strerror(struct perf_target *target, int errnum, char *buf,
                           size_t buflen);
 
-static inline bool perf_target__no_task(struct perf_target *target)
+static inline bool perf_target__has_task(struct perf_target *target)
 {
-        return !target->pid && !target->tid && !target->uid_str;
+        return target->tid || target->pid || target->uid_str;
 }
 
-static inline bool perf_target__no_cpu(struct perf_target *target)
+static inline bool perf_target__has_cpu(struct perf_target *target)
 {
-        return !target->system_wide && !target->cpu_list;
+        return target->system_wide || target->cpu_list;
 }
 
 static inline bool perf_target__none(struct perf_target *target)
 {
-        return perf_target__no_task(target) && perf_target__no_cpu(target);
+        return !perf_target__has_task(target) && !perf_target__has_cpu(target);
 }
 
 #endif /* _PERF_TARGET_H */