perf tests: Move test__vmlinux_matches_kallsyms into separate object
authorJiri Olsa <jolsa@redhat.com>
Sat, 10 Nov 2012 00:46:41 +0000 (01:46 +0100)
committerArnaldo Carvalho de Melo <acme@redhat.com>
Wed, 14 Nov 2012 19:48:35 +0000 (16:48 -0300)
Separating test__vmlinux_matches_kallsyms test from the builtin-test
into vmlinux-kallsyms object.

Signed-off-by: Jiri Olsa <jolsa@redhat.com>
Cc: Corey Ashford <cjashfor@linux.vnet.ibm.com>
Cc: Frederic Weisbecker <fweisbec@gmail.com>
Cc: Ingo Molnar <mingo@elte.hu>
Cc: Paul Mackerras <paulus@samba.org>
Cc: Peter Zijlstra <a.p.zijlstra@chello.nl>
Link: http://lkml.kernel.org/r/1352508412-16914-2-git-send-email-jolsa@redhat.com
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
tools/perf/Makefile
tools/perf/tests/builtin-test.c
tools/perf/tests/tests.h [new file with mode: 0644]
tools/perf/tests/vmlinux-kallsyms.c [new file with mode: 0644]

index cca5bb8334adf85df4050ef90ce2bef47611cc2b..7c7ba4d6dafd719aba519b84e952c71086034896 100644 (file)
@@ -431,6 +431,7 @@ LIB_OBJS += $(OUTPUT)arch/common.o
 LIB_OBJS += $(OUTPUT)tests/parse-events.o
 LIB_OBJS += $(OUTPUT)tests/dso-data.o
 LIB_OBJS += $(OUTPUT)tests/attr.o
+LIB_OBJS += $(OUTPUT)tests/vmlinux-kallsyms.o
 
 BUILTIN_OBJS += $(OUTPUT)builtin-annotate.o
 BUILTIN_OBJS += $(OUTPUT)builtin-bench.o
index 5d4354e244577a56c81e97a1cdc835f18264310d..5bc9063bf30fb96018af6260c9c54960ab8646fd 100644 (file)
 
 #include <sys/mman.h>
 
-static int vmlinux_matches_kallsyms_filter(struct map *map __maybe_unused,
-                                          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, *first_pair;
-               bool backwards = true;
-
-               sym  = rb_entry(nd, struct symbol, rb_node);
-
-               if (sym->start == sym->end)
-                       continue;
-
-               first_pair = machine__find_kernel_symbol(&kallsyms, type, sym->start, NULL, NULL);
-               pair = first_pair;
-
-               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("%#" PRIx64 ": diff end addr for %s v: %#" PRIx64 " k: %#" PRIx64 "\n",
-                                        sym->start, sym->name, sym->end, pair->end);
-                       } else {
-                               struct rb_node *nnd;
-detour:
-                               nnd = backwards ? rb_prev(&pair->rb_node) :
-                                                 rb_next(&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;
-                                       }
-                               }
-
-                               if (backwards) {
-                                       backwards = false;
-                                       pair = first_pair;
-                                       goto detour;
-                               }
-
-                               pr_debug("%#" PRIx64 ": diff name v: %s k: %s\n",
-                                        sym->start, sym->name, pair->name);
-                       }
-               } else
-                       pr_debug("%#" PRIx64 ": %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(" %" PRIx64 "-%" PRIx64 " %" PRIx64 " %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*%" PRIx64 "-%" PRIx64 " %" PRIx64 "",
-                                       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;
-}
-
 #include "util/cpumap.h"
 #include "util/evsel.h"
 #include <sys/types.h>
 
+#include "tests.h"
+
 static int trace_event__id(const char *evname)
 {
        char *filename;
diff --git a/tools/perf/tests/tests.h b/tools/perf/tests/tests.h
new file mode 100644 (file)
index 0000000..2223de5
--- /dev/null
@@ -0,0 +1,6 @@
+#ifndef TESTS_H
+#define TESTS_H
+
+int test__vmlinux_matches_kallsyms(void);
+
+#endif /* TESTS_H */
diff --git a/tools/perf/tests/vmlinux-kallsyms.c b/tools/perf/tests/vmlinux-kallsyms.c
new file mode 100644 (file)
index 0000000..0d1cdbe
--- /dev/null
@@ -0,0 +1,230 @@
+#include <linux/compiler.h>
+#include <linux/rbtree.h>
+#include <string.h>
+#include "map.h"
+#include "symbol.h"
+#include "util.h"
+#include "tests.h"
+#include "debug.h"
+#include "machine.h"
+
+static int vmlinux_matches_kallsyms_filter(struct map *map __maybe_unused,
+                                          struct symbol *sym)
+{
+       bool *visited = symbol__priv(sym);
+       *visited = true;
+       return 0;
+}
+
+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, *first_pair;
+               bool backwards = true;
+
+               sym  = rb_entry(nd, struct symbol, rb_node);
+
+               if (sym->start == sym->end)
+                       continue;
+
+               first_pair = machine__find_kernel_symbol(&kallsyms, type, sym->start, NULL, NULL);
+               pair = first_pair;
+
+               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("%#" PRIx64 ": diff end addr for %s v: %#" PRIx64 " k: %#" PRIx64 "\n",
+                                        sym->start, sym->name, sym->end, pair->end);
+                       } else {
+                               struct rb_node *nnd;
+detour:
+                               nnd = backwards ? rb_prev(&pair->rb_node) :
+                                                 rb_next(&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;
+                                       }
+                               }
+
+                               if (backwards) {
+                                       backwards = false;
+                                       pair = first_pair;
+                                       goto detour;
+                               }
+
+                               pr_debug("%#" PRIx64 ": diff name v: %s k: %s\n",
+                                        sym->start, sym->name, pair->name);
+                       }
+               } else
+                       pr_debug("%#" PRIx64 ": %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(" %" PRIx64 "-%" PRIx64 " %" PRIx64 " %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*%" PRIx64 "-%" PRIx64 " %" PRIx64 "",
+                                       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;
+}