6 files changed, 307 insertions, 0 deletions

diff --git a/tools/perf/Documentation/perf-test.txt b/tools/perf/Documentation/perf-test.txt
new file mode 100644
index 000000000000..1c4b5f5b7f71
--- /dev/null
+++ b/tools/perf/Documentation/perf-test.txt
@@ -0,0 +1,22 @@
+perf-test(1)
+============
+
+NAME
+----
+perf-test - Runs sanity tests.
+
+SYNOPSIS
+--------
+[verse]
+'perf test <options>'
+
+DESCRIPTION
+-----------
+This command does assorted sanity tests, initially thru linked routines but
+also will look for a directory with more tests in the form of scripts.
+
+OPTIONS
+-------
+-v::
+--verbose::
+        Be more verbose.
diff --git a/tools/perf/Makefile b/tools/perf/Makefile
index b86f2ad165ad..739c4412b183 100644
--- a/tools/perf/Makefile
+++ b/tools/perf/Makefile
@@ -490,6 +490,7 @@ BUILTIN_OBJS += $(OUTPUT)builtin-probe.o
 BUILTIN_OBJS += $(OUTPUT)builtin-kmem.o
 BUILTIN_OBJS += $(OUTPUT)builtin-lock.o
 BUILTIN_OBJS += $(OUTPUT)builtin-kvm.o
+BUILTIN_OBJS += $(OUTPUT)builtin-test.o
 
 PERFLIBS = $(LIB_FILE)
 
diff --git a/tools/perf/builtin-test.c b/tools/perf/builtin-test.c
new file mode 100644
index 000000000000..0339612e7385
--- /dev/null
+++ b/tools/perf/builtin-test.c
@@ -0,0 +1,281 @@
+/*
+ * builtin-test.c
+ *
+ * Builtin regression testing command: ever growing number of sanity tests
+ */
+#include "builtin.h"
+
+#include "util/cache.h"
+#include "util/debug.h"
+#include "util/parse-options.h"
+#include "util/session.h"
+#include "util/symbol.h"
+#include "util/thread.h"
+
+static long page_size;
+
+static int vmlinux_matches_kallsyms_filter(struct map *map __used, struct symbol *sym)
+{
+        bool *visited = symbol__priv(sym);
+        *visited = true;
+        return 0;
+}
+
+static int test__vmlinux_matches_kallsyms(void)
+{
+        int err = -1;
+        struct rb_node *nd;
+        struct symbol *sym;
+        struct map *kallsyms_map, *vmlinux_map;
+        struct machine kallsyms, vmlinux;
+        enum map_type type = MAP__FUNCTION;
+        struct ref_reloc_sym ref_reloc_sym = { .name = "_stext", };
+
+        /*
+         * Step 1:
+         *
+         * Init the machines that will hold kernel, modules obtained from
+         * both vmlinux + .ko files and from /proc/kallsyms split by modules.
+         */
+        machine__init(&kallsyms, "", HOST_KERNEL_ID);
+        machine__init(&vmlinux, "", HOST_KERNEL_ID);
+
+        /*
+         * Step 2:
+         *
+         * Create the kernel maps for kallsyms and the DSO where we will then
+         * load /proc/kallsyms. Also create the modules maps from /proc/modules
+         * and find the .ko files that match them in /lib/modules/`uname -r`/.
+         */
+        if (machine__create_kernel_maps(&kallsyms) < 0) {
+                pr_debug("machine__create_kernel_maps ");
+                return -1;
+        }
+
+        /*
+         * Step 3:
+         *
+         * Load and split /proc/kallsyms into multiple maps, one per module.
+         */
+        if (machine__load_kallsyms(&kallsyms, "/proc/kallsyms", type, NULL) <= 0) {
+                pr_debug("dso__load_kallsyms ");
+                goto out;
+        }
+
+        /*
+         * Step 4:
+         *
+         * kallsyms will be internally on demand sorted by name so that we can
+         * find the reference relocation * symbol, i.e. the symbol we will use
+         * to see if the running kernel was relocated by checking if it has the
+         * same value in the vmlinux file we load.
+         */
+        kallsyms_map = machine__kernel_map(&kallsyms, type);
+
+        sym = map__find_symbol_by_name(kallsyms_map, ref_reloc_sym.name, NULL);
+        if (sym == NULL) {
+                pr_debug("dso__find_symbol_by_name ");
+                goto out;
+        }
+
+        ref_reloc_sym.addr = sym->start;
+
+        /*
+         * Step 5:
+         *
+         * Now repeat step 2, this time for the vmlinux file we'll auto-locate.
+         */
+        if (machine__create_kernel_maps(&vmlinux) < 0) {
+                pr_debug("machine__create_kernel_maps ");
+                goto out;
+        }
+
+        vmlinux_map = machine__kernel_map(&vmlinux, type);
+        map__kmap(vmlinux_map)->ref_reloc_sym = &ref_reloc_sym;
+
+        /*
+         * Step 6:
+         *
+         * Locate a vmlinux file in the vmlinux path that has a buildid that
+         * matches the one of the running kernel.
+         *
+         * While doing that look if we find the ref reloc symbol, if we find it
+         * we'll have its ref_reloc_symbol.unrelocated_addr and then
+         * maps__reloc_vmlinux will notice and set proper ->[un]map_ip routines
+         * to fixup the symbols.
+         */
+        if (machine__load_vmlinux_path(&vmlinux, type,
+                                       vmlinux_matches_kallsyms_filter) <= 0) {
+                pr_debug("machine__load_vmlinux_path ");
+                goto out;
+        }
+
+        err = 0;
+        /*
+         * Step 7:
+         *
+         * Now look at the symbols in the vmlinux DSO and check if we find all of them
+         * in the kallsyms dso. For the ones that are in both, check its names and
+         * end addresses too.
+         */
+        for (nd = rb_first(&vmlinux_map->dso->symbols[type]); nd; nd = rb_next(nd)) {
+                struct symbol *pair;
+
+                sym  = rb_entry(nd, struct symbol, rb_node);
+                pair = machine__find_kernel_symbol(&kallsyms, type, sym->start, NULL, NULL);
+
+                if (pair && pair->start == sym->start) {
+next_pair:
+                        if (strcmp(sym->name, pair->name) == 0) {
+                                /*
+                                 * kallsyms don't have the symbol end, so we
+                                 * set that by using the next symbol start - 1,
+                                 * in some cases we get this up to a page
+                                 * wrong, trace_kmalloc when I was developing
+                                 * this code was one such example, 2106 bytes
+                                 * off the real size. More than that and we
+                                 * _really_ have a problem.
+                                 */
+                                s64 skew = sym->end - pair->end;
+                                if (llabs(skew) < page_size)
+                                        continue;
+
+                                pr_debug("%#Lx: diff end addr for %s v: %#Lx k: %#Lx\n",
+                                         sym->start, sym->name, sym->end, pair->end);
+                        } else {
+                                struct rb_node *nnd = rb_prev(&pair->rb_node);
+
+                                if (nnd) {
+                                        struct symbol *next = rb_entry(nnd, struct symbol, rb_node);
+
+                                        if (next->start == sym->start) {
+                                                pair = next;
+                                                goto next_pair;
+                                        }
+                                }
+                                pr_debug("%#Lx: diff name v: %s k: %s\n",
+                                         sym->start, sym->name, pair->name);
+                        }
+                } else
+                        pr_debug("%#Lx: %s not on kallsyms\n", sym->start, sym->name);
+
+                err = -1;
+        }
+
+        if (!verbose)
+                goto out;
+
+        pr_info("Maps only in vmlinux:\n");
+
+        for (nd = rb_first(&vmlinux.kmaps.maps[type]); nd; nd = rb_next(nd)) {
+                struct map *pos = rb_entry(nd, struct map, rb_node), *pair;
+                /*
+                 * If it is the kernel, kallsyms is always "[kernel.kallsyms]", while
+                 * the kernel will have the path for the vmlinux file being used,
+                 * so use the short name, less descriptive but the same ("[kernel]" in
+                 * both cases.
+                 */
+                pair = map_groups__find_by_name(&kallsyms.kmaps, type,
+                                                (pos->dso->kernel ?
+                                                        pos->dso->short_name :
+                                                        pos->dso->name));
+                if (pair)
+                        pair->priv = 1;
+                else
+                        map__fprintf(pos, stderr);
+        }
+
+        pr_info("Maps in vmlinux with a different name in kallsyms:\n");
+
+        for (nd = rb_first(&vmlinux.kmaps.maps[type]); nd; nd = rb_next(nd)) {
+                struct map *pos = rb_entry(nd, struct map, rb_node), *pair;
+
+                pair = map_groups__find(&kallsyms.kmaps, type, pos->start);
+                if (pair == NULL || pair->priv)
+                        continue;
+
+                if (pair->start == pos->start) {
+                        pair->priv = 1;
+                        pr_info(" %Lx-%Lx %Lx %s in kallsyms as",
+                                pos->start, pos->end, pos->pgoff, pos->dso->name);
+                        if (pos->pgoff != pair->pgoff || pos->end != pair->end)
+                                pr_info(": \n*%Lx-%Lx %Lx",
+                                        pair->start, pair->end, pair->pgoff);
+                        pr_info(" %s\n", pair->dso->name);
+                        pair->priv = 1;
+                }
+        }
+
+        pr_info("Maps only in kallsyms:\n");
+
+        for (nd = rb_first(&kallsyms.kmaps.maps[type]);
+             nd; nd = rb_next(nd)) {
+                struct map *pos = rb_entry(nd, struct map, rb_node);
+
+                if (!pos->priv)
+                        map__fprintf(pos, stderr);
+        }
+out:
+        return err;
+}
+
+static struct test {
+        const char *desc;
+        int (*func)(void);
+} tests[] = {
+        {
+                .desc = "vmlinux symtab matches kallsyms",
+                .func = test__vmlinux_matches_kallsyms,
+        },
+        {
+                .func = NULL,
+        },
+};
+
+static int __cmd_test(void)
+{
+        int i = 0;
+
+        page_size = sysconf(_SC_PAGE_SIZE);
+
+        while (tests[i].func) {
+                int err;
+                pr_info("%2d: %s:", i + 1, tests[i].desc);
+                pr_debug("\n--- start ---\n");
+                err = tests[i].func();
+                pr_debug("---- end ----\n%s:", tests[i].desc);
+                pr_info(" %s\n", err ? "FAILED!\n" : "Ok");
+                ++i;
+        }
+
+        return 0;
+}
+
+static const char * const test_usage[] = {
+        "perf test [<options>]",
+        NULL,
+};
+
+static const struct option test_options[] = {
+        OPT_BOOLEAN('v', "verbose", &verbose,
+                    "be more verbose (show symbol address, etc)"),
+        OPT_END()
+};
+
+int cmd_test(int argc, const char **argv, const char *prefix __used)
+{
+        argc = parse_options(argc, argv, test_options, test_usage, 0);
+        if (argc)
+                usage_with_options(test_usage, test_options);
+
+        symbol_conf.priv_size = sizeof(int);
+        symbol_conf.sort_by_name = true;
+        symbol_conf.try_vmlinux_path = true;
+
+        if (symbol__init() < 0)
+                return -1;
+
+        setup_pager();
+
+        return __cmd_test();
+}
diff --git a/tools/perf/builtin.h b/tools/perf/builtin.h
index ab28bca92e52..34a8a9ab9617 100644
--- a/tools/perf/builtin.h
+++ b/tools/perf/builtin.h
@@ -33,5 +33,6 @@ extern int cmd_probe(int argc, const char **argv, const char *prefix);
 extern int cmd_kmem(int argc, const char **argv, const char *prefix);
 extern int cmd_lock(int argc, const char **argv, const char *prefix);
 extern int cmd_kvm(int argc, const char **argv, const char *prefix);
+extern int cmd_test(int argc, const char **argv, const char *prefix);
 
 #endif
diff --git a/tools/perf/command-list.txt b/tools/perf/command-list.txt
index 2a1162d413a8..80a1a446ce35 100644
--- a/tools/perf/command-list.txt
+++ b/tools/perf/command-list.txt
@@ -20,3 +20,4 @@ perf-probe			mainporcelain common
 perf-kmem                       mainporcelain common
 perf-lock                       mainporcelain common
 perf-kvm                        mainporcelain common
+perf-test                       mainporcelain common
diff --git a/tools/perf/perf.c b/tools/perf/perf.c
index 985cdb4bd005..5ff9b5b46970 100644
--- a/tools/perf/perf.c
+++ b/tools/perf/perf.c
@@ -308,6 +308,7 @@ static void handle_internal_command(int argc, const char **argv)
                 { "kmem",       cmd_kmem,       0 },
                 { "lock",       cmd_lock,       0 },
                 { "kvm",        cmd_kvm,        0 },
+                { "test",       cmd_test,       0 },
         };
         unsigned int i;
         static const char ext[] = STRIP_EXTENSION;