perf tests vmlinux-kallsyms: Ignore hidden symbols

Certain kernel symbols are purposely hidden from kallsyms. The function
is_ignored_symbol() from scripts/kallsyms.c decides if a symbol should
be hidden or not.

The perf test "vmlinux symtab matches kallsyms" fails in case perf finds
some of the hidden symbols in its machine image and can't match them to
kallsyms.

Let's add a filter to check if a symbol not found isn't one of these
before failing the test.

The function is_ignored_symbol() has been copied from scripts/kallsyms.c
and needs to be updated along with the original.

Signed-off-by: Michael Petlan <mpetlan@redhat.com>
Acked-by: Ian Rogers <irogers@google.com>
Cc: Jiri Olsa <jolsa@kernel.org>
LPU-Reference: 20210922152706.23655-1-mpetlan@redhat.com
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>

diff --git a/tools/perf/tests/vmlinux-kallsyms.c b/tools/perf/tests/vmlinux-kallsyms.c
index 193b7c91b4e23d17d8f8bc1939c343ecb2017cfb..4f884aabc7f4ba055d01c3dd9b23e338e34a3153 100644 (file)
--- a/tools/perf/tests/vmlinux-kallsyms.c
+++ b/tools/perf/tests/vmlinux-kallsyms.c
@@ -3,6 +3,7 @@
 #include <linux/rbtree.h>
 #include <inttypes.h>
 #include <string.h>
+#include <ctype.h>
 #include <stdlib.h>
 #include "dso.h"
 #include "map.h"
@@ -14,6 +15,102 @@
 
 #define UM(x) kallsyms_map->unmap_ip(kallsyms_map, (x))
 
+static bool is_ignored_symbol(const char *name, char type)
+{
+       /* Symbol names that exactly match to the following are ignored.*/
+       static const char * const ignored_symbols[] = {
+               /*
+                * Symbols which vary between passes. Passes 1 and 2 must have
+                * identical symbol lists. The kallsyms_* symbols below are
+                * only added after pass 1, they would be included in pass 2
+                * when --all-symbols is specified so exclude them to get a
+                * stable symbol list.
+                */
+               "kallsyms_addresses",
+               "kallsyms_offsets",
+               "kallsyms_relative_base",
+               "kallsyms_num_syms",
+               "kallsyms_names",
+               "kallsyms_markers",
+               "kallsyms_token_table",
+               "kallsyms_token_index",
+               /* Exclude linker generated symbols which vary between passes */
+               "_SDA_BASE_",           /* ppc */
+               "_SDA2_BASE_",          /* ppc */
+               NULL
+       };
+
+       /* Symbol names that begin with the following are ignored.*/
+       static const char * const ignored_prefixes[] = {
+               "$",                    /* local symbols for ARM, MIPS, etc. */
+               ".LASANPC",             /* s390 kasan local symbols */
+               "__crc_",               /* modversions */
+               "__efistub_",           /* arm64 EFI stub namespace */
+               "__kvm_nvhe_",          /* arm64 non-VHE KVM namespace */
+               "__AArch64ADRPThunk_",  /* arm64 lld */
+               "__ARMV5PILongThunk_",  /* arm lld */
+               "__ARMV7PILongThunk_",
+               "__ThumbV7PILongThunk_",
+               "__LA25Thunk_",         /* mips lld */
+               "__microLA25Thunk_",
+               NULL
+       };
+
+       /* Symbol names that end with the following are ignored.*/
+       static const char * const ignored_suffixes[] = {
+               "_from_arm",            /* arm */
+               "_from_thumb",          /* arm */
+               "_veneer",              /* arm */
+               NULL
+       };
+
+       /* Symbol names that contain the following are ignored.*/
+       static const char * const ignored_matches[] = {
+               ".long_branch.",        /* ppc stub */
+               ".plt_branch.",         /* ppc stub */
+               NULL
+       };
+
+       const char * const *p;
+
+       for (p = ignored_symbols; *p; p++)
+               if (!strcmp(name, *p))
+                       return true;
+
+       for (p = ignored_prefixes; *p; p++)
+               if (!strncmp(name, *p, strlen(*p)))
+                       return true;
+
+       for (p = ignored_suffixes; *p; p++) {
+               int l = strlen(name) - strlen(*p);
+
+               if (l >= 0 && !strcmp(name + l, *p))
+                       return true;
+       }
+
+       for (p = ignored_matches; *p; p++) {
+               if (strstr(name, *p))
+                       return true;
+       }
+
+       if (type == 'U' || type == 'u')
+               return true;
+       /* exclude debugging symbols */
+       if (type == 'N' || type == 'n')
+               return true;
+
+       if (toupper(type) == 'A') {
+               /* Keep these useful absolute symbols */
+               if (strcmp(name, "__kernel_syscall_via_break") &&
+                   strcmp(name, "__kernel_syscall_via_epc") &&
+                   strcmp(name, "__kernel_sigtramp") &&
+                   strcmp(name, "__gp"))
+                       return true;
+       }
+
+       return false;
+}
+
 int test__vmlinux_matches_kallsyms(struct test *test __maybe_unused, int subtest __maybe_unused)
 {
        int err = -1;
@@ -169,6 +266,11 @@ next_pair:
                         * such as __indirect_thunk_end.
                         */
                        continue;
+               } else if (is_ignored_symbol(sym->name, sym->type)) {
+                       /*
+                        * Ignore hidden symbols, see scripts/kallsyms.c for the details
+                        */
+                       continue;
                } else {
                        pr_debug("ERR : %#" PRIx64 ": %s not on kallsyms\n",
                                 mem_start, sym->name);