Merge tag 'perf-core-for-mingo-20160713' 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:

User visible changes:

- Finish merging initial SDT (Statically Defined Traces) support, see
  cset comments for details about how it all works (Masami Hiramatsu)

- Support attaching eBPF programs to tracepoints (Wang Nan)

Infrastructure changes:

- Fix up BITS_PER_LONG setting (Arnaldo Carvalho de Melo)

- Add fallback from ELF_C_READ_MMAP to ELF_C_READ in objtool, fixing
  the build in libelf implementations lacking that elf_begin() cmd,
  such as Alpine Linux's (Arnaldo Carvalho de Melo)

- Avoid checking code drift on busybox's diff in objtool (Arnaldo Carvalho de Melo)

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

20 files changed, 725 insertions, 90 deletions

diff --git a/tools/perf/Documentation/perf-probe.txt b/tools/perf/Documentation/perf-probe.txt
index 7a258e953252..736da44596e4 100644
--- a/tools/perf/Documentation/perf-probe.txt
+++ b/tools/perf/Documentation/perf-probe.txt
@@ -151,6 +151,10 @@ Probe points are defined by following syntax.
     3) Define event based on source file with lazy pattern
      [[GROUP:]EVENT=]SRC;PTN [ARG ...]
 
+    4) Pre-defined SDT events or cached event with name
+     %[sdt_PROVIDER:]SDTEVENT
+     or,
+     sdt_PROVIDER:SDTEVENT
 
 'EVENT' specifies the name of new event, if omitted, it will be set the name of the probed function. You can also specify a group name by 'GROUP', if omitted, set 'probe' is used for kprobe and 'probe_<bin>' is used for uprobe.
 Note that using existing group name can conflict with other events. Especially, using the group name reserved for kernel modules can hide embedded events in the
@@ -158,6 +162,11 @@ modules.
 'FUNC' specifies a probed function name, and it may have one of the following options; '+OFFS' is the offset from function entry address in bytes, ':RLN' is the relative-line number from function entry line, and '%return' means that it probes function return. And ';PTN' means lazy matching pattern (see LAZY MATCHING). Note that ';PTN' must be the end of the probe point definition.  In addition, '@SRC' specifies a source file which has that function.
 It is also possible to specify a probe point by the source line number or lazy matching by using 'SRC:ALN' or 'SRC;PTN' syntax, where 'SRC' is the source file path, ':ALN' is the line number and ';PTN' is the lazy matching pattern.
 'ARG' specifies the arguments of this probe point, (see PROBE ARGUMENT).
+'SDTEVENT' and 'PROVIDER' is the pre-defined event name which is defined by user SDT (Statically Defined Tracing) or the pre-cached probes with event name.
+Note that before using the SDT event, the target binary (on which SDT events are defined) must be scanned by linkperf:perf-buildid-cache[1] to make SDT events as cached events.
+
+For details of the SDT, see below.
+https://sourceware.org/gdb/onlinedocs/gdb/Static-Probe-Points.html
 
 PROBE ARGUMENT
 --------------
@@ -237,4 +246,4 @@ Add probes at malloc() function on libc
 
 SEE ALSO
 --------
-linkperf:perf-trace[1], linkperf:perf-record[1]
+linkperf:perf-trace[1], linkperf:perf-record[1], linkperf:perf-buildid-cache[1]
diff --git a/tools/perf/Makefile.perf b/tools/perf/Makefile.perf
index feb2c66b110b..a129fbc1ed37 100644
--- a/tools/perf/Makefile.perf
+++ b/tools/perf/Makefile.perf
@@ -81,6 +81,9 @@ include ../scripts/utilities.mak
 #
 # Define NO_LIBBPF if you do not want BPF support
 #
+# Define NO_SDT if you do not want to define SDT event in perf tools,
+# note that it doesn't disable SDT scanning support.
+#
 # Define FEATURES_DUMP to provide features detection dump file
 # and bypass the feature detection
 
diff --git a/tools/perf/builtin-list.c b/tools/perf/builtin-list.c
index 5e22db4684b8..88ee419e5189 100644
--- a/tools/perf/builtin-list.c
+++ b/tools/perf/builtin-list.c
@@ -25,7 +25,7 @@ int cmd_list(int argc, const char **argv, const char *prefix __maybe_unused)
                 OPT_END()
         };
         const char * const list_usage[] = {
-                "perf list [hw|sw|cache|tracepoint|pmu|event_glob]",
+                "perf list [hw|sw|cache|tracepoint|pmu|sdt|event_glob]",
                 NULL
         };
 
@@ -62,6 +62,8 @@ int cmd_list(int argc, const char **argv, const char *prefix __maybe_unused)
                         print_hwcache_events(NULL, raw_dump);
                 else if (strcmp(argv[i], "pmu") == 0)
                         print_pmu_events(NULL, raw_dump);
+                else if (strcmp(argv[i], "sdt") == 0)
+                        print_sdt_events(NULL, NULL, raw_dump);
                 else if ((sep = strchr(argv[i], ':')) != NULL) {
                         int sep_idx;
 
@@ -76,6 +78,7 @@ int cmd_list(int argc, const char **argv, const char *prefix __maybe_unused)
 
                         s[sep_idx] = '\0';
                         print_tracepoint_events(s, s + sep_idx + 1, raw_dump);
+                        print_sdt_events(s, s + sep_idx + 1, raw_dump);
                         free(s);
                 } else {
                         if (asprintf(&s, "*%s*", argv[i]) < 0) {
@@ -89,6 +92,7 @@ int cmd_list(int argc, const char **argv, const char *prefix __maybe_unused)
                         print_hwcache_events(s, raw_dump);
                         print_pmu_events(s, raw_dump);
                         print_tracepoint_events(NULL, s, raw_dump);
+                        print_sdt_events(NULL, s, raw_dump);
                         free(s);
                 }
         }
diff --git a/tools/perf/builtin-probe.c b/tools/perf/builtin-probe.c
index c6d890ad2c1a..ee5b42173ba3 100644
--- a/tools/perf/builtin-probe.c
+++ b/tools/perf/builtin-probe.c
@@ -370,7 +370,7 @@ static int del_perf_probe_caches(struct strfilter *filter)
         struct str_node *nd;
         int ret;
 
-        bidlist = build_id_cache__list_all();
+        bidlist = build_id_cache__list_all(false);
         if (!bidlist) {
                 ret = -errno;
                 pr_debug("Failed to get buildids: %d\n", ret);
diff --git a/tools/perf/config/Makefile b/tools/perf/config/Makefile
index 5ac428060779..24803c58049a 100644
--- a/tools/perf/config/Makefile
+++ b/tools/perf/config/Makefile
@@ -355,6 +355,16 @@ ifndef NO_LIBELF
   endif # NO_LIBBPF
 endif # NO_LIBELF
 
+ifndef NO_SDT
+  ifneq ($(feature-sdt), 1)
+    msg := $(warning No sys/sdt.h found, no SDT events are defined, please install systemtap-sdt-devel or systemtap-sdt-dev);
+    NO_SDT := 1;
+  else
+    CFLAGS += -DHAVE_SDT_EVENT
+    $(call detected,CONFIG_SDT_EVENT)
+  endif
+endif
+
 ifdef PERF_HAVE_JITDUMP
   ifndef NO_DWARF
     $(call detected,CONFIG_JITDUMP)
diff --git a/tools/perf/tests/Build b/tools/perf/tests/Build
index 66a28982547b..4158422cc2a6 100644
--- a/tools/perf/tests/Build
+++ b/tools/perf/tests/Build
@@ -39,6 +39,7 @@ perf-y += stat.o
 perf-y += event_update.o
 perf-y += event-times.o
 perf-y += backward-ring-buffer.o
+perf-y += sdt.o
 
 $(OUTPUT)tests/llvm-src-base.c: tests/bpf-script-example.c tests/Build
         $(call rule_mkdir)
diff --git a/tools/perf/tests/builtin-test.c b/tools/perf/tests/builtin-test.c
index c23cbf733549..4dd2d050788a 100644
--- a/tools/perf/tests/builtin-test.c
+++ b/tools/perf/tests/builtin-test.c
@@ -218,6 +218,10 @@ static struct test generic_tests[] = {
                 .func = test__cpu_map_print,
         },
         {
+                .desc = "Test SDT event probing",
+                .func = test__sdt_event,
+        },
+        {
                 .func = NULL,
         },
 };
diff --git a/tools/perf/tests/make b/tools/perf/tests/make
index 51966d92fc82..143f4d549769 100644
--- a/tools/perf/tests/make
+++ b/tools/perf/tests/make
@@ -82,6 +82,7 @@ make_no_auxtrace    := NO_AUXTRACE=1
 make_no_libbpf      := NO_LIBBPF=1
 make_no_libcrypto   := NO_LIBCRYPTO=1
 make_with_babeltrace:= LIBBABELTRACE=1
+make_no_sdt         := NO_SDT=1
 make_tags           := tags
 make_cscope         := cscope
 make_help           := help
@@ -105,7 +106,7 @@ make_minimal        := NO_LIBPERL=1 NO_LIBPYTHON=1 NO_NEWT=1 NO_GTK2=1
 make_minimal        += NO_DEMANGLE=1 NO_LIBELF=1 NO_LIBUNWIND=1 NO_BACKTRACE=1
 make_minimal        += NO_LIBNUMA=1 NO_LIBAUDIT=1 NO_LIBBIONIC=1
 make_minimal        += NO_LIBDW_DWARF_UNWIND=1 NO_AUXTRACE=1 NO_LIBBPF=1
-make_minimal        += NO_LIBCRYPTO=1
+make_minimal        += NO_LIBCRYPTO=1 NO_SDT=1
 
 # $(run) contains all available tests
 run := make_pure
diff --git a/tools/perf/tests/sdt.c b/tools/perf/tests/sdt.c
new file mode 100644
index 000000000000..f59d210e1baf
--- /dev/null
+++ b/tools/perf/tests/sdt.c
@@ -0,0 +1,115 @@
+#include <stdio.h>
+#include <sys/epoll.h>
+#include <util/util.h>
+#include <util/evlist.h>
+#include <linux/filter.h>
+#include "tests.h"
+#include "debug.h"
+#include "probe-file.h"
+#include "build-id.h"
+
+/* To test SDT event, we need libelf support to scan elf binary */
+#if defined(HAVE_SDT_EVENT) && defined(HAVE_LIBELF_SUPPORT)
+
+#include <sys/sdt.h>
+
+static int target_function(void)
+{
+        DTRACE_PROBE(perf, test_target);
+        return TEST_OK;
+}
+
+/* Copied from builtin-buildid-cache.c */
+static int build_id_cache__add_file(const char *filename)
+{
+        char sbuild_id[SBUILD_ID_SIZE];
+        u8 build_id[BUILD_ID_SIZE];
+        int err;
+
+        err = filename__read_build_id(filename, &build_id, sizeof(build_id));
+        if (err < 0) {
+                pr_debug("Failed to read build id of %s\n", filename);
+                return err;
+        }
+
+        build_id__sprintf(build_id, sizeof(build_id), sbuild_id);
+        err = build_id_cache__add_s(sbuild_id, filename, false, false);
+        if (err < 0)
+                pr_debug("Failed to add build id cache of %s\n", filename);
+        return err;
+}
+
+static char *get_self_path(void)
+{
+        char *buf = calloc(PATH_MAX, sizeof(char));
+
+        if (buf && readlink("/proc/self/exe", buf, PATH_MAX) < 0) {
+                pr_debug("Failed to get correct path of perf\n");
+                free(buf);
+                return NULL;
+        }
+        return buf;
+}
+
+static int search_cached_probe(const char *target,
+                               const char *group, const char *event)
+{
+        struct probe_cache *cache = probe_cache__new(target);
+        int ret = 0;
+
+        if (!cache) {
+                pr_debug("Failed to open probe cache of %s\n", target);
+                return -EINVAL;
+        }
+
+        if (!probe_cache__find_by_name(cache, group, event)) {
+                pr_debug("Failed to find %s:%s in the cache\n", group, event);
+                ret = -ENOENT;
+        }
+        probe_cache__delete(cache);
+
+        return ret;
+}
+
+int test__sdt_event(int subtests __maybe_unused)
+{
+        int ret = TEST_FAIL;
+        char __tempdir[] = "./test-buildid-XXXXXX";
+        char *tempdir = NULL, *myself = get_self_path();
+
+        if (myself == NULL || mkdtemp(__tempdir) == NULL) {
+                pr_debug("Failed to make a tempdir for build-id cache\n");
+                goto error;
+        }
+        /* Note that buildid_dir must be an absolute path */
+        tempdir = realpath(__tempdir, NULL);
+
+        /* At first, scan itself */
+        set_buildid_dir(tempdir);
+        if (build_id_cache__add_file(myself) < 0)
+                goto error_rmdir;
+
+        /* Open a cache and make sure the SDT is stored */
+        if (search_cached_probe(myself, "sdt_perf", "test_target") < 0)
+                goto error_rmdir;
+
+        /* TBD: probing on the SDT event and collect logs */
+
+        /* Call the target and get an event */
+        ret = target_function();
+
+error_rmdir:
+        /* Cleanup temporary buildid dir */
+        rm_rf(tempdir);
+error:
+        free(tempdir);
+        free(myself);
+        return ret;
+}
+#else
+int test__sdt_event(int subtests __maybe_unused)
+{
+        pr_debug("Skip SDT event test because SDT support is not compiled\n");
+        return TEST_SKIP;
+}
+#endif
diff --git a/tools/perf/tests/tests.h b/tools/perf/tests/tests.h
index 52f969570c97..a0288f8092b2 100644
--- a/tools/perf/tests/tests.h
+++ b/tools/perf/tests/tests.h
@@ -88,6 +88,7 @@ int test__event_update(int subtest);
 int test__event_times(int subtest);
 int test__backward_ring_buffer(int subtest);
 int test__cpu_map_print(int subtest);
+int test__sdt_event(int subtest);
 
 #if defined(__arm__) || defined(__aarch64__)
 #ifdef HAVE_DWARF_UNWIND_SUPPORT
diff --git a/tools/perf/util/bpf-loader.c b/tools/perf/util/bpf-loader.c
index 8445e89621fe..1f12e4e40006 100644
--- a/tools/perf/util/bpf-loader.c
+++ b/tools/perf/util/bpf-loader.c
@@ -37,6 +37,9 @@ DEFINE_PRINT_FN(info, 1)
 DEFINE_PRINT_FN(debug, 1)
 
 struct bpf_prog_priv {
+        bool is_tp;
+        char *sys_name;
+        char *evt_name;
         struct perf_probe_event pev;
         bool need_prologue;
         struct bpf_insn *insns_buf;
@@ -118,6 +121,8 @@ clear_prog_priv(struct bpf_program *prog __maybe_unused,
         cleanup_perf_probe_events(&priv->pev, 1);
         zfree(&priv->insns_buf);
         zfree(&priv->type_mapping);
+        zfree(&priv->sys_name);
+        zfree(&priv->evt_name);
         free(priv);
 }
 
@@ -269,7 +274,8 @@ nextline:
 }
 
 static int
-parse_prog_config(const char *config_str, struct perf_probe_event *pev)
+parse_prog_config(const char *config_str, const char **p_main_str,
+                  bool *is_tp, struct perf_probe_event *pev)
 {
         int err;
         const char *main_str = parse_prog_config_kvpair(config_str, pev);
@@ -277,6 +283,22 @@ parse_prog_config(const char *config_str, struct perf_probe_event *pev)
         if (IS_ERR(main_str))
                 return PTR_ERR(main_str);
 
+        *p_main_str = main_str;
+        if (!strchr(main_str, '=')) {
+                /* Is a tracepoint event? */
+                const char *s = strchr(main_str, ':');
+
+                if (!s) {
+                        pr_debug("bpf: '%s' is not a valid tracepoint\n",
+                                 config_str);
+                        return -BPF_LOADER_ERRNO__CONFIG;
+                }
+
+                *is_tp = true;
+                return 0;
+        }
+
+        *is_tp = false;
         err = parse_perf_probe_command(main_str, pev);
         if (err < 0) {
                 pr_debug("bpf: '%s' is not a valid config string\n",
@@ -292,7 +314,8 @@ config_bpf_program(struct bpf_program *prog)
 {
         struct perf_probe_event *pev = NULL;
         struct bpf_prog_priv *priv = NULL;
-        const char *config_str;
+        const char *config_str, *main_str;
+        bool is_tp = false;
         int err;
 
         /* Initialize per-program probing setting */
@@ -313,10 +336,19 @@ config_bpf_program(struct bpf_program *prog)
         pev = &priv->pev;
 
         pr_debug("bpf: config program '%s'\n", config_str);
-        err = parse_prog_config(config_str, pev);
+        err = parse_prog_config(config_str, &main_str, &is_tp, pev);
         if (err)
                 goto errout;
 
+        if (is_tp) {
+                char *s = strchr(main_str, ':');
+
+                priv->is_tp = true;
+                priv->sys_name = strndup(main_str, s - main_str);
+                priv->evt_name = strdup(s + 1);
+                goto set_priv;
+        }
+
         if (pev->group && strcmp(pev->group, PERF_BPF_PROBE_GROUP)) {
                 pr_debug("bpf: '%s': group for event is set and not '%s'.\n",
                          config_str, PERF_BPF_PROBE_GROUP);
@@ -339,6 +371,7 @@ config_bpf_program(struct bpf_program *prog)
         }
         pr_debug("bpf: config '%s' is ok\n", config_str);
 
+set_priv:
         err = bpf_program__set_priv(prog, priv, clear_prog_priv);
         if (err) {
                 pr_debug("Failed to set priv for program '%s'\n", config_str);
@@ -387,7 +420,7 @@ preproc_gen_prologue(struct bpf_program *prog, int n,
         size_t prologue_cnt = 0;
         int i, err;
 
-        if (IS_ERR(priv) || !priv)
+        if (IS_ERR(priv) || !priv || priv->is_tp)
                 goto errout;
 
         pev = &priv->pev;
@@ -544,6 +577,11 @@ static int hook_load_preprocessor(struct bpf_program *prog)
                 return -BPF_LOADER_ERRNO__INTERNAL;
         }
 
+        if (priv->is_tp) {
+                priv->need_prologue = false;
+                return 0;
+        }
+
         pev = &priv->pev;
         for (i = 0; i < pev->ntevs; i++) {
                 struct probe_trace_event *tev = &pev->tevs[i];
@@ -610,6 +648,13 @@ int bpf__probe(struct bpf_object *obj)
                         err = PTR_ERR(priv);
                         goto out;
                 }
+
+                if (priv->is_tp) {
+                        bpf_program__set_tracepoint(prog);
+                        continue;
+                }
+
+                bpf_program__set_kprobe(prog);
                 pev = &priv->pev;
 
                 err = convert_perf_probe_events(pev, 1);
@@ -650,7 +695,7 @@ int bpf__unprobe(struct bpf_object *obj)
                 struct bpf_prog_priv *priv = bpf_program__priv(prog);
                 int i;
 
-                if (IS_ERR(priv) || !priv)
+                if (IS_ERR(priv) || !priv || priv->is_tp)
                         continue;
 
                 for (i = 0; i < priv->pev.ntevs; i++) {
@@ -693,9 +738,9 @@ int bpf__load(struct bpf_object *obj)
         return 0;
 }
 
-int bpf__foreach_tev(struct bpf_object *obj,
-                     bpf_prog_iter_callback_t func,
-                     void *arg)
+int bpf__foreach_event(struct bpf_object *obj,
+                       bpf_prog_iter_callback_t func,
+                       void *arg)
 {
         struct bpf_program *prog;
         int err;
@@ -711,6 +756,16 @@ int bpf__foreach_tev(struct bpf_object *obj,
                         return -BPF_LOADER_ERRNO__INTERNAL;
                 }
 
+                if (priv->is_tp) {
+                        fd = bpf_program__fd(prog);
+                        err = (*func)(priv->sys_name, priv->evt_name, fd, arg);
+                        if (err) {
+                                pr_debug("bpf: tracepoint call back failed, stop iterate\n");
+                                return err;
+                        }
+                        continue;
+                }
+
                 pev = &priv->pev;
                 for (i = 0; i < pev->ntevs; i++) {
                         tev = &pev->tevs[i];
@@ -728,7 +783,7 @@ int bpf__foreach_tev(struct bpf_object *obj,
                                 return fd;
                         }
 
-                        err = (*func)(tev, fd, arg);
+                        err = (*func)(tev->group, tev->event, fd, arg);
                         if (err) {
                                 pr_debug("bpf: call back failed, stop iterate\n");
                                 return err;
diff --git a/tools/perf/util/bpf-loader.h b/tools/perf/util/bpf-loader.h
index 941e17275aa7..f2b737b225f2 100644
--- a/tools/perf/util/bpf-loader.h
+++ b/tools/perf/util/bpf-loader.h
@@ -46,7 +46,7 @@ struct bpf_object;
 struct parse_events_term;
 #define PERF_BPF_PROBE_GROUP "perf_bpf_probe"
 
-typedef int (*bpf_prog_iter_callback_t)(struct probe_trace_event *tev,
+typedef int (*bpf_prog_iter_callback_t)(const char *group, const char *event,
                                         int fd, void *arg);
 
 #ifdef HAVE_LIBBPF_SUPPORT
@@ -67,8 +67,8 @@ int bpf__strerror_probe(struct bpf_object *obj, int err,
 int bpf__load(struct bpf_object *obj);
 int bpf__strerror_load(struct bpf_object *obj, int err,
                        char *buf, size_t size);
-int bpf__foreach_tev(struct bpf_object *obj,
-                     bpf_prog_iter_callback_t func, void *arg);
+int bpf__foreach_event(struct bpf_object *obj,
+                       bpf_prog_iter_callback_t func, void *arg);
 
 int bpf__config_obj(struct bpf_object *obj, struct parse_events_term *term,
                     struct perf_evlist *evlist, int *error_pos);
@@ -107,9 +107,9 @@ static inline int bpf__unprobe(struct bpf_object *obj __maybe_unused) { return 0
 static inline int bpf__load(struct bpf_object *obj __maybe_unused) { return 0; }
 
 static inline int
-bpf__foreach_tev(struct bpf_object *obj __maybe_unused,
-                 bpf_prog_iter_callback_t func __maybe_unused,
-                 void *arg __maybe_unused)
+bpf__foreach_event(struct bpf_object *obj __maybe_unused,
+                   bpf_prog_iter_callback_t func __maybe_unused,
+                   void *arg __maybe_unused)
 {
         return 0;
 }
diff --git a/tools/perf/util/build-id.c b/tools/perf/util/build-id.c
index 1e504e40dac8..5651f3c12f93 100644
--- a/tools/perf/util/build-id.c
+++ b/tools/perf/util/build-id.c
@@ -206,6 +206,31 @@ out:
         return ret;
 }
 
+/* Check if the given build_id cache is valid on current running system */
+static bool build_id_cache__valid_id(char *sbuild_id)
+{
+        char real_sbuild_id[SBUILD_ID_SIZE] = "";
+        char *pathname;
+        int ret = 0;
+        bool result = false;
+
+        pathname = build_id_cache__origname(sbuild_id);
+        if (!pathname)
+                return false;
+
+        if (!strcmp(pathname, DSO__NAME_KALLSYMS))
+                ret = sysfs__sprintf_build_id("/", real_sbuild_id);
+        else if (pathname[0] == '/')
+                ret = filename__sprintf_build_id(pathname, real_sbuild_id);
+        else
+                ret = -EINVAL;  /* Should we support other special DSO cache? */
+        if (ret >= 0)
+                result = (strcmp(sbuild_id, real_sbuild_id) == 0);
+        free(pathname);
+
+        return result;
+}
+
 static const char *build_id_cache__basename(bool is_kallsyms, bool is_vdso)
 {
         return is_kallsyms ? "kallsyms" : (is_vdso ? "vdso" : "elf");
@@ -433,13 +458,17 @@ static bool lsdir_bid_tail_filter(const char *name __maybe_unused,
         return (i == SBUILD_ID_SIZE - 3) && (d->d_name[i] == '\0');
 }
 
-struct strlist *build_id_cache__list_all(void)
+struct strlist *build_id_cache__list_all(bool validonly)
 {
         struct strlist *toplist, *linklist = NULL, *bidlist;
         struct str_node *nd, *nd2;
         char *topdir, *linkdir = NULL;
         char sbuild_id[SBUILD_ID_SIZE];
 
+        /* for filename__ functions */
+        if (validonly)
+                symbol__init(NULL);
+
         /* Open the top-level directory */
         if (asprintf(&topdir, "%s/.build-id/", buildid_dir) < 0)
                 return NULL;
@@ -470,6 +499,8 @@ struct strlist *build_id_cache__list_all(void)
                         if (snprintf(sbuild_id, SBUILD_ID_SIZE, "%s%s",
                                      nd->s, nd2->s) != SBUILD_ID_SIZE - 1)
                                 goto err_out;
+                        if (validonly && !build_id_cache__valid_id(sbuild_id))
+                                continue;
                         if (strlist__add(bidlist, sbuild_id) < 0)
                                 goto err_out;
                 }
@@ -492,6 +523,49 @@ err_out:
         goto out_free;
 }
 
+static bool str_is_build_id(const char *maybe_sbuild_id, size_t len)
+{
+        size_t i;
+
+        for (i = 0; i < len; i++) {
+                if (!isxdigit(maybe_sbuild_id[i]))
+                        return false;
+        }
+        return true;
+}
+
+/* Return the valid complete build-id */
+char *build_id_cache__complement(const char *incomplete_sbuild_id)
+{
+        struct strlist *bidlist;
+        struct str_node *nd, *cand = NULL;
+        char *sbuild_id = NULL;
+        size_t len = strlen(incomplete_sbuild_id);
+
+        if (len >= SBUILD_ID_SIZE ||
+            !str_is_build_id(incomplete_sbuild_id, len))
+                return NULL;
+
+        bidlist = build_id_cache__list_all(true);
+        if (!bidlist)
+                return NULL;
+
+        strlist__for_each_entry(nd, bidlist) {
+                if (strncmp(nd->s, incomplete_sbuild_id, len) != 0)
+                        continue;
+                if (cand) {     /* Error: There are more than 2 candidates. */
+                        cand = NULL;
+                        break;
+                }
+                cand = nd;
+        }
+        if (cand)
+                sbuild_id = strdup(cand->s);
+        strlist__delete(bidlist);
+
+        return sbuild_id;
+}
+
 char *build_id_cache__cachedir(const char *sbuild_id, const char *name,
                                bool is_kallsyms, bool is_vdso)
 {
diff --git a/tools/perf/util/build-id.h b/tools/perf/util/build-id.h
index b742e271ea2c..d27990610f9f 100644
--- a/tools/perf/util/build-id.h
+++ b/tools/perf/util/build-id.h
@@ -34,7 +34,8 @@ char *build_id_cache__origname(const char *sbuild_id);
 char *build_id_cache__linkname(const char *sbuild_id, char *bf, size_t size);
 char *build_id_cache__cachedir(const char *sbuild_id, const char *name,
                                bool is_kallsyms, bool is_vdso);
-struct strlist *build_id_cache__list_all(void);
+struct strlist *build_id_cache__list_all(bool validonly);
+char *build_id_cache__complement(const char *incomplete_sbuild_id);
 int build_id_cache__list_build_ids(const char *pathname,
                                    struct strlist **result);
 bool build_id_cache__cached(const char *sbuild_id);
diff --git a/tools/perf/util/parse-events.c b/tools/perf/util/parse-events.c
index ebd87b773f56..375af0e02831 100644
--- a/tools/perf/util/parse-events.c
+++ b/tools/perf/util/parse-events.c
@@ -20,6 +20,7 @@
 #include "pmu.h"
 #include "thread_map.h"
 #include "cpumap.h"
+#include "probe-file.h"
 #include "asm/bug.h"
 
 #define MAX_NAME_LEN 100
@@ -436,7 +437,7 @@ int parse_events_add_cache(struct list_head *list, int *idx,
 }
 
 static void tracepoint_error(struct parse_events_error *e, int err,
-                             char *sys, char *name)
+                             const char *sys, const char *name)
 {
         char help[BUFSIZ];
 
@@ -466,7 +467,7 @@ static void tracepoint_error(struct parse_events_error *e, int err,
 }
 
 static int add_tracepoint(struct list_head *list, int *idx,
-                          char *sys_name, char *evt_name,
+                          const char *sys_name, const char *evt_name,
                           struct parse_events_error *err,
                           struct list_head *head_config)
 {
@@ -491,7 +492,7 @@ static int add_tracepoint(struct list_head *list, int *idx,
 }
 
 static int add_tracepoint_multi_event(struct list_head *list, int *idx,
-                                      char *sys_name, char *evt_name,
+                                      const char *sys_name, const char *evt_name,
                                       struct parse_events_error *err,
                                       struct list_head *head_config)
 {
@@ -533,7 +534,7 @@ static int add_tracepoint_multi_event(struct list_head *list, int *idx,
 }
 
 static int add_tracepoint_event(struct list_head *list, int *idx,
-                                char *sys_name, char *evt_name,
+                                const char *sys_name, const char *evt_name,
                                 struct parse_events_error *err,
                                 struct list_head *head_config)
 {
@@ -545,7 +546,7 @@ static int add_tracepoint_event(struct list_head *list, int *idx,
 }
 
 static int add_tracepoint_multi_sys(struct list_head *list, int *idx,
-                                    char *sys_name, char *evt_name,
+                                    const char *sys_name, const char *evt_name,
                                     struct parse_events_error *err,
                                     struct list_head *head_config)
 {
@@ -584,7 +585,7 @@ struct __add_bpf_event_param {
         struct list_head *head_config;
 };
 
-static int add_bpf_event(struct probe_trace_event *tev, int fd,
+static int add_bpf_event(const char *group, const char *event, int fd,
                          void *_param)
 {
         LIST_HEAD(new_evsels);
@@ -595,27 +596,27 @@ static int add_bpf_event(struct probe_trace_event *tev, int fd,
         int err;
 
         pr_debug("add bpf event %s:%s and attach bpf program %d\n",
-                 tev->group, tev->event, fd);
+                 group, event, fd);
 
-        err = parse_events_add_tracepoint(&new_evsels, &evlist->idx, tev->group,
-                                          tev->event, evlist->error,
+        err = parse_events_add_tracepoint(&new_evsels, &evlist->idx, group,
+                                          event, evlist->error,
                                           param->head_config);
         if (err) {
                 struct perf_evsel *evsel, *tmp;
 
                 pr_debug("Failed to add BPF event %s:%s\n",
-                         tev->group, tev->event);
+                         group, event);
                 list_for_each_entry_safe(evsel, tmp, &new_evsels, node) {
                         list_del(&evsel->node);
                         perf_evsel__delete(evsel);
                 }
                 return err;
         }
-        pr_debug("adding %s:%s\n", tev->group, tev->event);
+        pr_debug("adding %s:%s\n", group, event);
 
         list_for_each_entry(pos, &new_evsels, node) {
                 pr_debug("adding %s:%s to %p\n",
-                         tev->group, tev->event, pos);
+                         group, event, pos);
                 pos->bpf_fd = fd;
         }
         list_splice(&new_evsels, list);
@@ -661,7 +662,7 @@ int parse_events_load_bpf_obj(struct parse_events_evlist *data,
                 goto errout;
         }
 
-        err = bpf__foreach_tev(obj, add_bpf_event, &param);
+        err = bpf__foreach_event(obj, add_bpf_event, &param);
         if (err) {
                 snprintf(errbuf, sizeof(errbuf),
                          "Attach events in BPF object failed");
@@ -1126,7 +1127,7 @@ do {								\
 }
 
 int parse_events_add_tracepoint(struct list_head *list, int *idx,
-                                char *sys, char *event,
+                                const char *sys, const char *event,
                                 struct parse_events_error *err,
                                 struct list_head *head_config)
 {
@@ -1984,6 +1985,85 @@ static bool is_event_supported(u8 type, unsigned config)
         return ret;
 }
 
+void print_sdt_events(const char *subsys_glob, const char *event_glob,
+                      bool name_only)
+{
+        struct probe_cache *pcache;
+        struct probe_cache_entry *ent;
+        struct strlist *bidlist, *sdtlist;
+        struct strlist_config cfg = {.dont_dupstr = true};
+        struct str_node *nd, *nd2;
+        char *buf, *path, *ptr = NULL;
+        bool show_detail = false;
+        int ret;
+
+        sdtlist = strlist__new(NULL, &cfg);
+        if (!sdtlist) {
+                pr_debug("Failed to allocate new strlist for SDT\n");
+                return;
+        }
+        bidlist = build_id_cache__list_all(true);
+        if (!bidlist) {
+                pr_debug("Failed to get buildids: %d\n", errno);
+                return;
+        }
+        strlist__for_each_entry(nd, bidlist) {
+                pcache = probe_cache__new(nd->s);
+                if (!pcache)
+                        continue;
+                list_for_each_entry(ent, &pcache->entries, node) {
+                        if (!ent->sdt)
+                                continue;
+                        if (subsys_glob &&
+                            !strglobmatch(ent->pev.group, subsys_glob))
+                                continue;
+                        if (event_glob &&
+                            !strglobmatch(ent->pev.event, event_glob))
+                                continue;
+                        ret = asprintf(&buf, "%s:%s@%s", ent->pev.group,
+                                        ent->pev.event, nd->s);
+                        if (ret > 0)
+                                strlist__add(sdtlist, buf);
+                }
+                probe_cache__delete(pcache);
+        }
+        strlist__delete(bidlist);
+
+        strlist__for_each_entry(nd, sdtlist) {
+                buf = strchr(nd->s, '@');
+                if (buf)
+                        *(buf++) = '\0';
+                if (name_only) {
+                        printf("%s ", nd->s);
+                        continue;
+                }
+                nd2 = strlist__next(nd);
+                if (nd2) {
+                        ptr = strchr(nd2->s, '@');
+                        if (ptr)
+                                *ptr = '\0';
+                        if (strcmp(nd->s, nd2->s) == 0)
+                                show_detail = true;
+                }
+                if (show_detail) {
+                        path = build_id_cache__origname(buf);
+                        ret = asprintf(&buf, "%s@%s(%.12s)", nd->s, path, buf);
+                        if (ret > 0) {
+                                printf("  %-50s [%s]\n", buf, "SDT event");
+                                free(buf);
+                        }
+                } else
+                        printf("  %-50s [%s]\n", nd->s, "SDT event");
+                if (nd2) {
+                        if (strcmp(nd->s, nd2->s) != 0)
+                                show_detail = false;
+                        if (ptr)
+                                *ptr = '@';
+                }
+        }
+        strlist__delete(sdtlist);
+}
+
 int print_hwcache_events(const char *event_glob, bool name_only)
 {
         unsigned int type, op, i, evt_i = 0, evt_num = 0;
@@ -2166,6 +2246,8 @@ void print_events(const char *event_glob, bool name_only)
         }
 
         print_tracepoint_events(NULL, NULL, name_only);
+
+        print_sdt_events(NULL, NULL, name_only);
 }
 
 int parse_events__is_hardcoded_term(struct parse_events_term *term)
diff --git a/tools/perf/util/parse-events.h b/tools/perf/util/parse-events.h
index 46c05ccd5dfe..b4aa7eb2df73 100644
--- a/tools/perf/util/parse-events.h
+++ b/tools/perf/util/parse-events.h
@@ -134,7 +134,7 @@ int parse_events__modifier_event(struct list_head *list, char *str, bool add);
 int parse_events__modifier_group(struct list_head *list, char *event_mod);
 int parse_events_name(struct list_head *list, char *name);
 int parse_events_add_tracepoint(struct list_head *list, int *idx,
-                                char *sys, char *event,
+                                const char *sys, const char *event,
                                 struct parse_events_error *error,
                                 struct list_head *head_config);
 int parse_events_load_bpf(struct parse_events_evlist *data,
@@ -183,6 +183,8 @@ void print_symbol_events(const char *event_glob, unsigned type,
 void print_tracepoint_events(const char *subsys_glob, const char *event_glob,
                              bool name_only);
 int print_hwcache_events(const char *event_glob, bool name_only);
+void print_sdt_events(const char *subsys_glob, const char *event_glob,
+                      bool name_only);
 int is_valid_tracepoint(const char *event_string);
 
 int valid_event_mount(const char *eventfs);
diff --git a/tools/perf/util/probe-event.c b/tools/perf/util/probe-event.c
index 2b222a7955c9..d4f8835c0a27 100644
--- a/tools/perf/util/probe-event.c
+++ b/tools/perf/util/probe-event.c
@@ -1197,6 +1197,34 @@ err:
         return err;
 }
 
+static int parse_perf_probe_event_name(char **arg, struct perf_probe_event *pev)
+{
+        char *ptr;
+
+        ptr = strchr(*arg, ':');
+        if (ptr) {
+                *ptr = '\0';
+                if (!pev->sdt && !is_c_func_name(*arg))
+                        goto ng_name;
+                pev->group = strdup(*arg);
+                if (!pev->group)
+                        return -ENOMEM;
+                *arg = ptr + 1;
+        } else
+                pev->group = NULL;
+        if (!pev->sdt && !is_c_func_name(*arg)) {
+ng_name:
+                semantic_error("%s is bad for event name -it must "
+                               "follow C symbol-naming rule.\n", *arg);
+                return -EINVAL;
+        }
+        pev->event = strdup(*arg);
+        if (pev->event == NULL)
+                return -ENOMEM;
+
+        return 0;
+}
+
 /* Parse probepoint definition. */
 static int parse_perf_probe_point(char *arg, struct perf_probe_event *pev)
 {
@@ -1204,38 +1232,64 @@ static int parse_perf_probe_point(char *arg, struct perf_probe_event *pev)
         char *ptr, *tmp;
         char c, nc = 0;
         bool file_spec = false;
+        int ret;
+
         /*
          * <Syntax>
          * perf probe [GRP:][EVENT=]SRC[:LN|;PTN]
          * perf probe [GRP:][EVENT=]FUNC[@SRC][+OFFS|%return|:LN|;PAT]
+         * perf probe %[GRP:]SDT_EVENT
          */
         if (!arg)
                 return -EINVAL;
 
+        /*
+         * If the probe point starts with '%',
+         * or starts with "sdt_" and has a ':' but no '=',
+         * then it should be a SDT/cached probe point.
+         */
+        if (arg[0] == '%' ||
+            (!strncmp(arg, "sdt_", 4) &&
+             !!strchr(arg, ':') && !strchr(arg, '='))) {
+                pev->sdt = true;
+                if (arg[0] == '%')
+                        arg++;
+        }
+
         ptr = strpbrk(arg, ";=@+%");
-        if (ptr && *ptr == '=') {       /* Event name */
-                *ptr = '\0';
-                tmp = ptr + 1;
-                ptr = strchr(arg, ':');
+        if (pev->sdt) {
                 if (ptr) {
-                        *ptr = '\0';
-                        if (!is_c_func_name(arg))
-                                goto not_fname;
-                        pev->group = strdup(arg);
-                        if (!pev->group)
+                        if (*ptr != '@') {
+                                semantic_error("%s must be an SDT name.\n",
+                                               arg);
+                                return -EINVAL;
+                        }
+                        /* This must be a target file name or build id */
+                        tmp = build_id_cache__complement(ptr + 1);
+                        if (tmp) {
+                                pev->target = build_id_cache__origname(tmp);
+                                free(tmp);
+                        } else
+                                pev->target = strdup(ptr + 1);
+                        if (!pev->target)
                                 return -ENOMEM;
-                        arg = ptr + 1;
-                } else
-                        pev->group = NULL;
-                if (!is_c_func_name(arg)) {
-not_fname:
-                        semantic_error("%s is bad for event name -it must "
-                                       "follow C symbol-naming rule.\n", arg);
-                        return -EINVAL;
+                        *ptr = '\0';
                 }
-                pev->event = strdup(arg);
-                if (pev->event == NULL)
-                        return -ENOMEM;
+                ret = parse_perf_probe_event_name(&arg, pev);
+                if (ret == 0) {
+                        if (asprintf(&pev->point.function, "%%%s", pev->event) < 0)
+                                ret = -errno;
+                }
+                return ret;
+        }
+
+        if (ptr && *ptr == '=') {       /* Event name */
+                *ptr = '\0';
+                tmp = ptr + 1;
+                ret = parse_perf_probe_event_name(&arg, pev);
+                if (ret < 0)
+                        return ret;
+
                 arg = tmp;
         }
 
@@ -1547,7 +1601,9 @@ bool perf_probe_event_need_dwarf(struct perf_probe_event *pev)
                 return true;
 
         for (i = 0; i < pev->nargs; i++)
-                if (is_c_varname(pev->args[i].var))
+                if (is_c_varname(pev->args[i].var) ||
+                    !strcmp(pev->args[i].var, "$params") ||
+                    !strcmp(pev->args[i].var, "$vars"))
                         return true;
 
         return false;
@@ -1609,6 +1665,7 @@ int parse_probe_trace_command(const char *cmd, struct probe_trace_event *tev)
                         ret = -ENOMEM;
                         goto out;
                 }
+                tev->uprobes = (tp->module[0] == '/');
                 p++;
         } else
                 p = argv[1];
@@ -2483,7 +2540,7 @@ static int probe_trace_event__set_name(struct probe_trace_event *tev,
         int ret;
 
         /* If probe_event or trace_event already have the name, reuse it */
-        if (pev->event)
+        if (pev->event && !pev->sdt)
                 event = pev->event;
         else if (tev->event)
                 event = tev->event;
@@ -2496,7 +2553,7 @@ static int probe_trace_event__set_name(struct probe_trace_event *tev,
                 else
                         event = tev->point.realname;
         }
-        if (pev->group)
+        if (pev->group && !pev->sdt)
                 group = pev->group;
         else if (tev->group)
                 group = tev->group;
@@ -2521,41 +2578,60 @@ static int probe_trace_event__set_name(struct probe_trace_event *tev,
         return 0;
 }
 
-static int __add_probe_trace_events(struct perf_probe_event *pev,
-                                     struct probe_trace_event *tevs,
-                                     int ntevs, bool allow_suffix)
+static int __open_probe_file_and_namelist(bool uprobe,
+                                          struct strlist **namelist)
 {
-        int i, fd, ret;
-        struct probe_trace_event *tev = NULL;
-        struct probe_cache *cache = NULL;
-        struct strlist *namelist;
+        int fd;
 
-        fd = probe_file__open(PF_FL_RW | (pev->uprobes ? PF_FL_UPROBE : 0));
+        fd = probe_file__open(PF_FL_RW | (uprobe ? PF_FL_UPROBE : 0));
         if (fd < 0)
                 return fd;
 
         /* Get current event names */
-        namelist = probe_file__get_namelist(fd);
-        if (!namelist) {
+        *namelist = probe_file__get_namelist(fd);
+        if (!(*namelist)) {
                 pr_debug("Failed to get current event list.\n");
-                ret = -ENOMEM;
-                goto close_out;
+                close(fd);
+                return -ENOMEM;
         }
+        return fd;
+}
+
+static int __add_probe_trace_events(struct perf_probe_event *pev,
+                                     struct probe_trace_event *tevs,
+                                     int ntevs, bool allow_suffix)
+{
+        int i, fd[2] = {-1, -1}, up, ret;
+        struct probe_trace_event *tev = NULL;
+        struct probe_cache *cache = NULL;
+        struct strlist *namelist[2] = {NULL, NULL};
+
+        up = pev->uprobes ? 1 : 0;
+        fd[up] = __open_probe_file_and_namelist(up, &namelist[up]);
+        if (fd[up] < 0)
+                return fd[up];
 
         ret = 0;
         for (i = 0; i < ntevs; i++) {
                 tev = &tevs[i];
+                up = tev->uprobes ? 1 : 0;
+                if (fd[up] == -1) {     /* Open the kprobe/uprobe_events */
+                        fd[up] = __open_probe_file_and_namelist(up,
+                                                                &namelist[up]);
+                        if (fd[up] < 0)
+                                goto close_out;
+                }
                 /* Skip if the symbol is out of .text or blacklisted */
                 if (!tev->point.symbol && !pev->uprobes)
                         continue;
 
                 /* Set new name for tev (and update namelist) */
-                ret = probe_trace_event__set_name(tev, pev, namelist,
+                ret = probe_trace_event__set_name(tev, pev, namelist[up],
                                                   allow_suffix);
                 if (ret < 0)
                         break;
 
-                ret = probe_file__add_event(fd, tev);
+                ret = probe_file__add_event(fd[up], tev);
                 if (ret < 0)
                         break;
 
@@ -2578,9 +2654,12 @@ static int __add_probe_trace_events(struct perf_probe_event *pev,
                 probe_cache__delete(cache);
         }
 
-        strlist__delete(namelist);
 close_out:
-        close(fd);
+        for (up = 0; up < 2; up++) {
+                strlist__delete(namelist[up]);
+                if (fd[up] >= 0)
+                        close(fd[up]);
+        }
         return ret;
 }
 
@@ -2859,6 +2938,142 @@ errout:
 
 bool __weak arch__prefers_symtab(void) { return false; }
 
+/* Concatinate two arrays */
+static void *memcat(void *a, size_t sz_a, void *b, size_t sz_b)
+{
+        void *ret;
+
+        ret = malloc(sz_a + sz_b);
+        if (ret) {
+                memcpy(ret, a, sz_a);
+                memcpy(ret + sz_a, b, sz_b);
+        }
+        return ret;
+}
+
+static int
+concat_probe_trace_events(struct probe_trace_event **tevs, int *ntevs,
+                          struct probe_trace_event **tevs2, int ntevs2)
+{
+        struct probe_trace_event *new_tevs;
+        int ret = 0;
+
+        if (ntevs == 0) {
+                *tevs = *tevs2;
+                *ntevs = ntevs2;
+                *tevs2 = NULL;
+                return 0;
+        }
+
+        if (*ntevs + ntevs2 > probe_conf.max_probes)
+                ret = -E2BIG;
+        else {
+                /* Concatinate the array of probe_trace_event */
+                new_tevs = memcat(*tevs, (*ntevs) * sizeof(**tevs),
+                                  *tevs2, ntevs2 * sizeof(**tevs2));
+                if (!new_tevs)
+                        ret = -ENOMEM;
+                else {
+                        free(*tevs);
+                        *tevs = new_tevs;
+                        *ntevs += ntevs2;
+                }
+        }
+        if (ret < 0)
+                clear_probe_trace_events(*tevs2, ntevs2);
+        zfree(tevs2);
+
+        return ret;
+}
+
+/*
+ * Try to find probe_trace_event from given probe caches. Return the number
+ * of cached events found, if an error occurs return the error.
+ */
+static int find_cached_events(struct perf_probe_event *pev,
+                              struct probe_trace_event **tevs,
+                              const char *target)
+{
+        struct probe_cache *cache;
+        struct probe_cache_entry *entry;
+        struct probe_trace_event *tmp_tevs = NULL;
+        int ntevs = 0;
+        int ret = 0;
+
+        cache = probe_cache__new(target);
+        /* Return 0 ("not found") if the target has no probe cache. */
+        if (!cache)
+                return 0;
+
+        for_each_probe_cache_entry(entry, cache) {
+                /* Skip the cache entry which has no name */
+                if (!entry->pev.event || !entry->pev.group)
+                        continue;
+                if ((!pev->group || strglobmatch(entry->pev.group, pev->group)) &&
+                    strglobmatch(entry->pev.event, pev->event)) {
+                        ret = probe_cache_entry__get_event(entry, &tmp_tevs);
+                        if (ret > 0)
+                                ret = concat_probe_trace_events(tevs, &ntevs,
+                                                                &tmp_tevs, ret);
+                        if (ret < 0)
+                                break;
+                }
+        }
+        probe_cache__delete(cache);
+        if (ret < 0) {
+                clear_probe_trace_events(*tevs, ntevs);
+                zfree(tevs);
+        } else {
+                ret = ntevs;
+                if (ntevs > 0 && target && target[0] == '/')
+                        pev->uprobes = true;
+        }
+
+        return ret;
+}
+
+/* Try to find probe_trace_event from all probe caches */
+static int find_cached_events_all(struct perf_probe_event *pev,
+                                   struct probe_trace_event **tevs)
+{
+        struct probe_trace_event *tmp_tevs = NULL;
+        struct strlist *bidlist;
+        struct str_node *nd;
+        char *pathname;
+        int ntevs = 0;
+        int ret;
+
+        /* Get the buildid list of all valid caches */
+        bidlist = build_id_cache__list_all(true);
+        if (!bidlist) {
+                ret = -errno;
+                pr_debug("Failed to get buildids: %d\n", ret);
+                return ret;
+        }
+
+        ret = 0;
+        strlist__for_each_entry(nd, bidlist) {
+                pathname = build_id_cache__origname(nd->s);
+                ret = find_cached_events(pev, &tmp_tevs, pathname);
+                /* In the case of cnt == 0, we just skip it */
+                if (ret > 0)
+                        ret = concat_probe_trace_events(tevs, &ntevs,
+                                                        &tmp_tevs, ret);
+                free(pathname);
+                if (ret < 0)
+                        break;
+        }
+        strlist__delete(bidlist);
+
+        if (ret < 0) {
+                clear_probe_trace_events(*tevs, ntevs);
+                zfree(tevs);
+        } else
+                ret = ntevs;
+
+        return ret;
+}
+
 static int find_probe_trace_events_from_cache(struct perf_probe_event *pev,
                                               struct probe_trace_event **tevs)
 {
@@ -2868,13 +3083,21 @@ static int find_probe_trace_events_from_cache(struct perf_probe_event *pev,
         struct str_node *node;
         int ret, i;
 
+        if (pev->sdt) {
+                /* For SDT/cached events, we use special search functions */
+                if (!pev->target)
+                        return find_cached_events_all(pev, tevs);
+                else
+                        return find_cached_events(pev, tevs, pev->target);
+        }
         cache = probe_cache__new(pev->target);
         if (!cache)
                 return 0;
 
         entry = probe_cache__find(cache, pev);
         if (!entry) {
-                ret = 0;
+                /* SDT must be in the cache */
+                ret = pev->sdt ? -ENOENT : 0;
                 goto out;
         }
 
@@ -2913,7 +3136,7 @@ static int convert_to_probe_trace_events(struct perf_probe_event *pev,
 {
         int ret;
 
-        if (!pev->group) {
+        if (!pev->group && !pev->sdt) {
                 /* Set group name if not given */
                 if (!pev->uprobes) {
                         pev->group = strdup(PERFPROBE_GROUP);
@@ -2932,8 +3155,8 @@ static int convert_to_probe_trace_events(struct perf_probe_event *pev,
 
         /* At first, we need to lookup cache entry */
         ret = find_probe_trace_events_from_cache(pev, tevs);
-        if (ret > 0)
-                return ret;     /* Found in probe cache */
+        if (ret > 0 || pev->sdt)        /* SDT can be found only in the cache */
+                return ret == 0 ? -ENOENT : ret; /* Found in probe cache */
 
         if (arch__prefers_symtab() && !perf_probe_event_need_dwarf(pev)) {
                 ret = find_probe_trace_events_from_map(pev, tevs);
diff --git a/tools/perf/util/probe-event.h b/tools/perf/util/probe-event.h
index 432b690d3f17..e18ea9fe6385 100644
--- a/tools/perf/util/probe-event.h
+++ b/tools/perf/util/probe-event.h
@@ -85,6 +85,7 @@ struct perf_probe_event {
         char                    *group; /* Group name */
         struct perf_probe_point point;  /* Probe point */
         int                     nargs;  /* Number of arguments */
+        bool                    sdt;    /* SDT/cached event flag */
         bool                    uprobes;        /* Uprobe event flag */
         char                    *target;        /* Target binary */
         struct perf_probe_arg   *args;  /* Arguments */
diff --git a/tools/perf/util/probe-file.c b/tools/perf/util/probe-file.c
index e705a742ee1e..9aed9c332da6 100644
--- a/tools/perf/util/probe-file.c
+++ b/tools/perf/util/probe-file.c
@@ -362,13 +362,38 @@ probe_cache_entry__new(struct perf_probe_event *pev)
         return entry;
 }
 
-/* For the kernel probe caches, pass target = NULL */
+int probe_cache_entry__get_event(struct probe_cache_entry *entry,
+                                 struct probe_trace_event **tevs)
+{
+        struct probe_trace_event *tev;
+        struct str_node *node;
+        int ret, i;
+
+        ret = strlist__nr_entries(entry->tevlist);
+        if (ret > probe_conf.max_probes)
+                return -E2BIG;
+
+        *tevs = zalloc(ret * sizeof(*tev));
+        if (!*tevs)
+                return -ENOMEM;
+
+        i = 0;
+        strlist__for_each_entry(node, entry->tevlist) {
+                tev = &(*tevs)[i++];
+                ret = parse_probe_trace_command(node->s, tev);
+                if (ret < 0)
+                        break;
+        }
+        return i;
+}
+
+/* For the kernel probe caches, pass target = NULL or DSO__NAME_KALLSYMS */
 static int probe_cache__open(struct probe_cache *pcache, const char *target)
 {
         char cpath[PATH_MAX];
         char sbuildid[SBUILD_ID_SIZE];
         char *dir_name = NULL;
-        bool is_kallsyms = !target;
+        bool is_kallsyms = false;
         int ret, fd;
 
         if (target && build_id_cache__cached(target)) {
@@ -378,12 +403,13 @@ static int probe_cache__open(struct probe_cache *pcache, const char *target)
                 goto found;
         }
 
-        if (target)
-                ret = filename__sprintf_build_id(target, sbuildid);
-        else {
+        if (!target || !strcmp(target, DSO__NAME_KALLSYMS)) {
                 target = DSO__NAME_KALLSYMS;
+                is_kallsyms = true;
                 ret = sysfs__sprintf_build_id("/", sbuildid);
-        }
+        } else
+                ret = filename__sprintf_build_id(target, sbuildid);
+
         if (ret < 0) {
                 pr_debug("Failed to get build-id from %s.\n", target);
                 return ret;
@@ -546,7 +572,16 @@ probe_cache__find(struct probe_cache *pcache, struct perf_probe_event *pev)
         if (!cmd)
                 return NULL;
 
-        list_for_each_entry(entry, &pcache->entries, node) {
+        for_each_probe_cache_entry(entry, pcache) {
+                if (pev->sdt) {
+                        if (entry->pev.event &&
+                            streql(entry->pev.event, pev->event) &&
+                            (!pev->group ||
+                             streql(entry->pev.group, pev->group)))
+                                goto found;
+
+                        continue;
+                }
                 /* Hit if same event name or same command-string */
                 if ((pev->event &&
                      (streql(entry->pev.group, pev->group) &&
@@ -567,7 +602,7 @@ probe_cache__find_by_name(struct probe_cache *pcache,
 {
         struct probe_cache_entry *entry = NULL;
 
-        list_for_each_entry(entry, &pcache->entries, node) {
+        for_each_probe_cache_entry(entry, pcache) {
                 /* Hit if same event name or same command-string */
                 if (streql(entry->pev.group, group) &&
                     streql(entry->pev.event, event))
@@ -739,7 +774,7 @@ int probe_cache__commit(struct probe_cache *pcache)
         if (ret < 0)
                 goto out;
 
-        list_for_each_entry(entry, &pcache->entries, node) {
+        for_each_probe_cache_entry(entry, pcache) {
                 ret = probe_cache_entry__write(entry, pcache->fd);
                 pr_debug("Cache committed: %d\n", ret);
                 if (ret < 0)
@@ -781,7 +816,7 @@ static int probe_cache__show_entries(struct probe_cache *pcache,
 {
         struct probe_cache_entry *entry;
 
-        list_for_each_entry(entry, &pcache->entries, node) {
+        for_each_probe_cache_entry(entry, pcache) {
                 if (probe_cache_entry__compare(entry, filter))
                         printf("%s\n", entry->spev);
         }
@@ -799,7 +834,7 @@ int probe_cache__show_all_caches(struct strfilter *filter)
         pr_debug("list cache with filter: %s\n", buf);
         free(buf);
 
-        bidlist = build_id_cache__list_all();
+        bidlist = build_id_cache__list_all(true);
         if (!bidlist) {
                 pr_debug("Failed to get buildids: %d\n", errno);
                 return -EINVAL;
diff --git a/tools/perf/util/probe-file.h b/tools/perf/util/probe-file.h
index ddf5ae212c2f..9577b5c0b487 100644
--- a/tools/perf/util/probe-file.h
+++ b/tools/perf/util/probe-file.h
@@ -21,7 +21,11 @@ struct probe_cache {
 
 #define PF_FL_UPROBE    1
 #define PF_FL_RW        2
+#define for_each_probe_cache_entry(entry, pcache) \
+        list_for_each_entry(entry, &pcache->entries, node)
 
+/* probe-file.c depends on libelf */
+#ifdef HAVE_LIBELF_SUPPORT
 int probe_file__open(int flag);
 int probe_file__open_both(int *kfd, int *ufd, int flag);
 struct strlist *probe_file__get_namelist(int fd);
@@ -32,6 +36,9 @@ int probe_file__get_events(int fd, struct strfilter *filter,
                                   struct strlist *plist);
 int probe_file__del_strlist(int fd, struct strlist *namelist);
 
+int probe_cache_entry__get_event(struct probe_cache_entry *entry,
+                                 struct probe_trace_event **tevs);
+
 struct probe_cache *probe_cache__new(const char *target);
 int probe_cache__add_entry(struct probe_cache *pcache,
                            struct perf_probe_event *pev,
@@ -47,4 +54,11 @@ struct probe_cache_entry *probe_cache__find(struct probe_cache *pcache,
 struct probe_cache_entry *probe_cache__find_by_name(struct probe_cache *pcache,
                                         const char *group, const char *event);
 int probe_cache__show_all_caches(struct strfilter *filter);
+#else   /* ! HAVE_LIBELF_SUPPORT */
+static inline struct probe_cache *probe_cache__new(const char *tgt __maybe_unused)
+{
+        return NULL;
+}
+#define probe_cache__delete(pcache) do {} while (0)
+#endif
 #endif