Jiri Olsa | 0a4e1ae | 2012-11-10 01:46:41 +0100 | [diff] [blame] | 1 | #include <linux/compiler.h> |
| 2 | #include <linux/rbtree.h> |
| 3 | #include <string.h> |
| 4 | #include "map.h" |
| 5 | #include "symbol.h" |
| 6 | #include "util.h" |
| 7 | #include "tests.h" |
| 8 | #include "debug.h" |
| 9 | #include "machine.h" |
| 10 | |
Adrian Hunter | 82e75d0 | 2013-08-07 14:38:52 +0300 | [diff] [blame] | 11 | #define UM(x) kallsyms_map->unmap_ip(kallsyms_map, (x)) |
| 12 | |
Arnaldo Carvalho de Melo | 721a1f5 | 2015-11-19 12:01:48 -0300 | [diff] [blame] | 13 | int test__vmlinux_matches_kallsyms(int subtest __maybe_unused) |
Jiri Olsa | 0a4e1ae | 2012-11-10 01:46:41 +0100 | [diff] [blame] | 14 | { |
| 15 | int err = -1; |
| 16 | struct rb_node *nd; |
| 17 | struct symbol *sym; |
Arnaldo Carvalho de Melo | 4bb7123d | 2015-05-22 11:52:22 -0300 | [diff] [blame] | 18 | struct map *kallsyms_map, *vmlinux_map, *map; |
Jiri Olsa | 0a4e1ae | 2012-11-10 01:46:41 +0100 | [diff] [blame] | 19 | struct machine kallsyms, vmlinux; |
| 20 | enum map_type type = MAP__FUNCTION; |
Arnaldo Carvalho de Melo | 1eee78a | 2015-05-22 12:58:53 -0300 | [diff] [blame] | 21 | struct maps *maps = &vmlinux.kmaps.maps[type]; |
Adrian Hunter | d380b34 | 2013-08-07 14:38:48 +0300 | [diff] [blame] | 22 | u64 mem_start, mem_end; |
Arnaldo Carvalho de Melo | 54da076 | 2016-09-01 10:40:57 -0300 | [diff] [blame] | 23 | bool header_printed; |
Jiri Olsa | 0a4e1ae | 2012-11-10 01:46:41 +0100 | [diff] [blame] | 24 | |
| 25 | /* |
| 26 | * Step 1: |
| 27 | * |
| 28 | * Init the machines that will hold kernel, modules obtained from |
| 29 | * both vmlinux + .ko files and from /proc/kallsyms split by modules. |
| 30 | */ |
| 31 | machine__init(&kallsyms, "", HOST_KERNEL_ID); |
| 32 | machine__init(&vmlinux, "", HOST_KERNEL_ID); |
| 33 | |
| 34 | /* |
| 35 | * Step 2: |
| 36 | * |
| 37 | * Create the kernel maps for kallsyms and the DSO where we will then |
| 38 | * load /proc/kallsyms. Also create the modules maps from /proc/modules |
| 39 | * and find the .ko files that match them in /lib/modules/`uname -r`/. |
| 40 | */ |
| 41 | if (machine__create_kernel_maps(&kallsyms) < 0) { |
| 42 | pr_debug("machine__create_kernel_maps "); |
Arnaldo Carvalho de Melo | c0aab59 | 2013-01-24 23:01:50 -0300 | [diff] [blame] | 43 | goto out; |
Jiri Olsa | 0a4e1ae | 2012-11-10 01:46:41 +0100 | [diff] [blame] | 44 | } |
| 45 | |
| 46 | /* |
| 47 | * Step 3: |
| 48 | * |
| 49 | * Load and split /proc/kallsyms into multiple maps, one per module. |
Arnaldo Carvalho de Melo | 53d0fe6 | 2016-04-19 12:16:55 -0300 | [diff] [blame] | 50 | * Do not use kcore, as this test was designed before kcore support |
| 51 | * and has parts that only make sense if using the non-kcore code. |
| 52 | * XXX: extend it to stress the kcorre code as well, hint: the list |
| 53 | * of modules extracted from /proc/kcore, in its current form, can't |
| 54 | * be compacted against the list of modules found in the "vmlinux" |
| 55 | * code and with the one got from /proc/modules from the "kallsyms" code. |
Jiri Olsa | 0a4e1ae | 2012-11-10 01:46:41 +0100 | [diff] [blame] | 56 | */ |
Arnaldo Carvalho de Melo | be39db9 | 2016-09-01 19:25:52 -0300 | [diff] [blame] | 57 | if (__machine__load_kallsyms(&kallsyms, "/proc/kallsyms", type, true) <= 0) { |
Jiri Olsa | 0a4e1ae | 2012-11-10 01:46:41 +0100 | [diff] [blame] | 58 | pr_debug("dso__load_kallsyms "); |
| 59 | goto out; |
| 60 | } |
| 61 | |
| 62 | /* |
| 63 | * Step 4: |
| 64 | * |
| 65 | * kallsyms will be internally on demand sorted by name so that we can |
| 66 | * find the reference relocation * symbol, i.e. the symbol we will use |
| 67 | * to see if the running kernel was relocated by checking if it has the |
| 68 | * same value in the vmlinux file we load. |
| 69 | */ |
Arnaldo Carvalho de Melo | a5e813c | 2015-09-30 11:54:04 -0300 | [diff] [blame] | 70 | kallsyms_map = machine__kernel_map(&kallsyms); |
Jiri Olsa | 0a4e1ae | 2012-11-10 01:46:41 +0100 | [diff] [blame] | 71 | |
Jiri Olsa | 0a4e1ae | 2012-11-10 01:46:41 +0100 | [diff] [blame] | 72 | /* |
| 73 | * Step 5: |
| 74 | * |
| 75 | * Now repeat step 2, this time for the vmlinux file we'll auto-locate. |
| 76 | */ |
| 77 | if (machine__create_kernel_maps(&vmlinux) < 0) { |
| 78 | pr_debug("machine__create_kernel_maps "); |
| 79 | goto out; |
| 80 | } |
| 81 | |
Arnaldo Carvalho de Melo | a5e813c | 2015-09-30 11:54:04 -0300 | [diff] [blame] | 82 | vmlinux_map = machine__kernel_map(&vmlinux); |
Jiri Olsa | 0a4e1ae | 2012-11-10 01:46:41 +0100 | [diff] [blame] | 83 | |
| 84 | /* |
| 85 | * Step 6: |
| 86 | * |
| 87 | * Locate a vmlinux file in the vmlinux path that has a buildid that |
| 88 | * matches the one of the running kernel. |
| 89 | * |
| 90 | * While doing that look if we find the ref reloc symbol, if we find it |
| 91 | * we'll have its ref_reloc_symbol.unrelocated_addr and then |
| 92 | * maps__reloc_vmlinux will notice and set proper ->[un]map_ip routines |
| 93 | * to fixup the symbols. |
| 94 | */ |
Arnaldo Carvalho de Melo | be39db9 | 2016-09-01 19:25:52 -0300 | [diff] [blame] | 95 | if (machine__load_vmlinux_path(&vmlinux, type) <= 0) { |
Arnaldo Carvalho de Melo | 531f67b | 2012-12-19 11:11:59 -0300 | [diff] [blame] | 96 | pr_debug("Couldn't find a vmlinux that matches the kernel running on this machine, skipping test\n"); |
| 97 | err = TEST_SKIP; |
Jiri Olsa | 0a4e1ae | 2012-11-10 01:46:41 +0100 | [diff] [blame] | 98 | goto out; |
| 99 | } |
| 100 | |
| 101 | err = 0; |
| 102 | /* |
| 103 | * Step 7: |
| 104 | * |
| 105 | * Now look at the symbols in the vmlinux DSO and check if we find all of them |
| 106 | * in the kallsyms dso. For the ones that are in both, check its names and |
| 107 | * end addresses too. |
| 108 | */ |
| 109 | for (nd = rb_first(&vmlinux_map->dso->symbols[type]); nd; nd = rb_next(nd)) { |
| 110 | struct symbol *pair, *first_pair; |
Jiri Olsa | 0a4e1ae | 2012-11-10 01:46:41 +0100 | [diff] [blame] | 111 | |
| 112 | sym = rb_entry(nd, struct symbol, rb_node); |
| 113 | |
| 114 | if (sym->start == sym->end) |
| 115 | continue; |
| 116 | |
Adrian Hunter | d380b34 | 2013-08-07 14:38:48 +0300 | [diff] [blame] | 117 | mem_start = vmlinux_map->unmap_ip(vmlinux_map, sym->start); |
| 118 | mem_end = vmlinux_map->unmap_ip(vmlinux_map, sym->end); |
| 119 | |
| 120 | first_pair = machine__find_kernel_symbol(&kallsyms, type, |
Arnaldo Carvalho de Melo | be39db9 | 2016-09-01 19:25:52 -0300 | [diff] [blame] | 121 | mem_start, NULL); |
Jiri Olsa | 0a4e1ae | 2012-11-10 01:46:41 +0100 | [diff] [blame] | 122 | pair = first_pair; |
| 123 | |
Adrian Hunter | 82e75d0 | 2013-08-07 14:38:52 +0300 | [diff] [blame] | 124 | if (pair && UM(pair->start) == mem_start) { |
Jiri Olsa | 0a4e1ae | 2012-11-10 01:46:41 +0100 | [diff] [blame] | 125 | next_pair: |
Jiri Olsa | f97276c | 2018-02-15 13:26:35 +0100 | [diff] [blame] | 126 | if (arch__compare_symbol_names(sym->name, pair->name) == 0) { |
Jiri Olsa | 0a4e1ae | 2012-11-10 01:46:41 +0100 | [diff] [blame] | 127 | /* |
| 128 | * kallsyms don't have the symbol end, so we |
| 129 | * set that by using the next symbol start - 1, |
| 130 | * in some cases we get this up to a page |
| 131 | * wrong, trace_kmalloc when I was developing |
| 132 | * this code was one such example, 2106 bytes |
| 133 | * off the real size. More than that and we |
| 134 | * _really_ have a problem. |
| 135 | */ |
Adrian Hunter | 82e75d0 | 2013-08-07 14:38:52 +0300 | [diff] [blame] | 136 | s64 skew = mem_end - UM(pair->end); |
Jiri Olsa | 5888a8c | 2013-06-07 15:37:02 +0200 | [diff] [blame] | 137 | if (llabs(skew) >= page_size) |
Arnaldo Carvalho de Melo | e267769 | 2016-09-01 10:26:49 -0300 | [diff] [blame] | 138 | pr_debug("WARN: %#" PRIx64 ": diff end addr for %s v: %#" PRIx64 " k: %#" PRIx64 "\n", |
Adrian Hunter | d380b34 | 2013-08-07 14:38:48 +0300 | [diff] [blame] | 139 | mem_start, sym->name, mem_end, |
Adrian Hunter | 82e75d0 | 2013-08-07 14:38:52 +0300 | [diff] [blame] | 140 | UM(pair->end)); |
Jiri Olsa | 0a4e1ae | 2012-11-10 01:46:41 +0100 | [diff] [blame] | 141 | |
Jiri Olsa | 5888a8c | 2013-06-07 15:37:02 +0200 | [diff] [blame] | 142 | /* |
| 143 | * Do not count this as a failure, because we |
| 144 | * could really find a case where it's not |
| 145 | * possible to get proper function end from |
| 146 | * kallsyms. |
| 147 | */ |
| 148 | continue; |
Jiri Olsa | 0a4e1ae | 2012-11-10 01:46:41 +0100 | [diff] [blame] | 149 | } else { |
Arnaldo Carvalho de Melo | be39db9 | 2016-09-01 19:25:52 -0300 | [diff] [blame] | 150 | pair = machine__find_kernel_symbol_by_name(&kallsyms, type, sym->name, NULL); |
Arnaldo Carvalho de Melo | ab414dc | 2016-01-25 18:04:47 -0300 | [diff] [blame] | 151 | if (pair) { |
| 152 | if (UM(pair->start) == mem_start) |
Jiri Olsa | 0a4e1ae | 2012-11-10 01:46:41 +0100 | [diff] [blame] | 153 | goto next_pair; |
Jiri Olsa | 0a4e1ae | 2012-11-10 01:46:41 +0100 | [diff] [blame] | 154 | |
Arnaldo Carvalho de Melo | 7e1b659 | 2016-09-01 10:40:57 -0300 | [diff] [blame] | 155 | pr_debug("WARN: %#" PRIx64 ": diff name v: %s k: %s\n", |
Arnaldo Carvalho de Melo | ab414dc | 2016-01-25 18:04:47 -0300 | [diff] [blame] | 156 | mem_start, sym->name, pair->name); |
Arnaldo Carvalho de Melo | 6566fea | 2016-04-19 12:22:25 -0300 | [diff] [blame] | 157 | } else { |
Arnaldo Carvalho de Melo | 7e1b659 | 2016-09-01 10:40:57 -0300 | [diff] [blame] | 158 | pr_debug("WARN: %#" PRIx64 ": diff name v: %s k: %s\n", |
Arnaldo Carvalho de Melo | 6566fea | 2016-04-19 12:22:25 -0300 | [diff] [blame] | 159 | mem_start, sym->name, first_pair->name); |
Jiri Olsa | 0a4e1ae | 2012-11-10 01:46:41 +0100 | [diff] [blame] | 160 | } |
Arnaldo Carvalho de Melo | 7e1b659 | 2016-09-01 10:40:57 -0300 | [diff] [blame] | 161 | |
| 162 | continue; |
Jiri Olsa | 0a4e1ae | 2012-11-10 01:46:41 +0100 | [diff] [blame] | 163 | } |
| 164 | } else |
Arnaldo Carvalho de Melo | e267769 | 2016-09-01 10:26:49 -0300 | [diff] [blame] | 165 | pr_debug("ERR : %#" PRIx64 ": %s not on kallsyms\n", |
Adrian Hunter | d380b34 | 2013-08-07 14:38:48 +0300 | [diff] [blame] | 166 | mem_start, sym->name); |
Jiri Olsa | 0a4e1ae | 2012-11-10 01:46:41 +0100 | [diff] [blame] | 167 | |
| 168 | err = -1; |
| 169 | } |
| 170 | |
| 171 | if (!verbose) |
| 172 | goto out; |
| 173 | |
Arnaldo Carvalho de Melo | 54da076 | 2016-09-01 10:40:57 -0300 | [diff] [blame] | 174 | header_printed = false; |
Jiri Olsa | 0a4e1ae | 2012-11-10 01:46:41 +0100 | [diff] [blame] | 175 | |
Arnaldo Carvalho de Melo | 4bb7123d | 2015-05-22 11:52:22 -0300 | [diff] [blame] | 176 | for (map = maps__first(maps); map; map = map__next(map)) { |
| 177 | struct map * |
Jiri Olsa | 0a4e1ae | 2012-11-10 01:46:41 +0100 | [diff] [blame] | 178 | /* |
| 179 | * If it is the kernel, kallsyms is always "[kernel.kallsyms]", while |
| 180 | * the kernel will have the path for the vmlinux file being used, |
| 181 | * so use the short name, less descriptive but the same ("[kernel]" in |
| 182 | * both cases. |
| 183 | */ |
| 184 | pair = map_groups__find_by_name(&kallsyms.kmaps, type, |
Arnaldo Carvalho de Melo | 4bb7123d | 2015-05-22 11:52:22 -0300 | [diff] [blame] | 185 | (map->dso->kernel ? |
| 186 | map->dso->short_name : |
| 187 | map->dso->name)); |
Arnaldo Carvalho de Melo | 54da076 | 2016-09-01 10:40:57 -0300 | [diff] [blame] | 188 | if (pair) { |
Jiri Olsa | 0a4e1ae | 2012-11-10 01:46:41 +0100 | [diff] [blame] | 189 | pair->priv = 1; |
Arnaldo Carvalho de Melo | 54da076 | 2016-09-01 10:40:57 -0300 | [diff] [blame] | 190 | } else { |
| 191 | if (!header_printed) { |
| 192 | pr_info("WARN: Maps only in vmlinux:\n"); |
| 193 | header_printed = true; |
| 194 | } |
Arnaldo Carvalho de Melo | 4bb7123d | 2015-05-22 11:52:22 -0300 | [diff] [blame] | 195 | map__fprintf(map, stderr); |
Arnaldo Carvalho de Melo | 54da076 | 2016-09-01 10:40:57 -0300 | [diff] [blame] | 196 | } |
Jiri Olsa | 0a4e1ae | 2012-11-10 01:46:41 +0100 | [diff] [blame] | 197 | } |
| 198 | |
Arnaldo Carvalho de Melo | 54da076 | 2016-09-01 10:40:57 -0300 | [diff] [blame] | 199 | header_printed = false; |
Jiri Olsa | 0a4e1ae | 2012-11-10 01:46:41 +0100 | [diff] [blame] | 200 | |
Arnaldo Carvalho de Melo | 4bb7123d | 2015-05-22 11:52:22 -0300 | [diff] [blame] | 201 | for (map = maps__first(maps); map; map = map__next(map)) { |
| 202 | struct map *pair; |
Jiri Olsa | 0a4e1ae | 2012-11-10 01:46:41 +0100 | [diff] [blame] | 203 | |
Arnaldo Carvalho de Melo | 4bb7123d | 2015-05-22 11:52:22 -0300 | [diff] [blame] | 204 | mem_start = vmlinux_map->unmap_ip(vmlinux_map, map->start); |
| 205 | mem_end = vmlinux_map->unmap_ip(vmlinux_map, map->end); |
Adrian Hunter | d380b34 | 2013-08-07 14:38:48 +0300 | [diff] [blame] | 206 | |
| 207 | pair = map_groups__find(&kallsyms.kmaps, type, mem_start); |
Jiri Olsa | 0a4e1ae | 2012-11-10 01:46:41 +0100 | [diff] [blame] | 208 | if (pair == NULL || pair->priv) |
| 209 | continue; |
| 210 | |
Adrian Hunter | d380b34 | 2013-08-07 14:38:48 +0300 | [diff] [blame] | 211 | if (pair->start == mem_start) { |
Arnaldo Carvalho de Melo | 54da076 | 2016-09-01 10:40:57 -0300 | [diff] [blame] | 212 | if (!header_printed) { |
| 213 | pr_info("WARN: Maps in vmlinux with a different name in kallsyms:\n"); |
| 214 | header_printed = true; |
| 215 | } |
| 216 | |
Arnaldo Carvalho de Melo | e267769 | 2016-09-01 10:26:49 -0300 | [diff] [blame] | 217 | pr_info("WARN: %" PRIx64 "-%" PRIx64 " %" PRIx64 " %s in kallsyms as", |
Arnaldo Carvalho de Melo | 4bb7123d | 2015-05-22 11:52:22 -0300 | [diff] [blame] | 218 | map->start, map->end, map->pgoff, map->dso->name); |
Adrian Hunter | d380b34 | 2013-08-07 14:38:48 +0300 | [diff] [blame] | 219 | if (mem_end != pair->end) |
Arnaldo Carvalho de Melo | e267769 | 2016-09-01 10:26:49 -0300 | [diff] [blame] | 220 | pr_info(":\nWARN: *%" PRIx64 "-%" PRIx64 " %" PRIx64, |
Jiri Olsa | 0a4e1ae | 2012-11-10 01:46:41 +0100 | [diff] [blame] | 221 | pair->start, pair->end, pair->pgoff); |
| 222 | pr_info(" %s\n", pair->dso->name); |
| 223 | pair->priv = 1; |
| 224 | } |
| 225 | } |
| 226 | |
Arnaldo Carvalho de Melo | 54da076 | 2016-09-01 10:40:57 -0300 | [diff] [blame] | 227 | header_printed = false; |
Jiri Olsa | 0a4e1ae | 2012-11-10 01:46:41 +0100 | [diff] [blame] | 228 | |
Arnaldo Carvalho de Melo | 4bb7123d | 2015-05-22 11:52:22 -0300 | [diff] [blame] | 229 | maps = &kallsyms.kmaps.maps[type]; |
Jiri Olsa | 0a4e1ae | 2012-11-10 01:46:41 +0100 | [diff] [blame] | 230 | |
Arnaldo Carvalho de Melo | 4bb7123d | 2015-05-22 11:52:22 -0300 | [diff] [blame] | 231 | for (map = maps__first(maps); map; map = map__next(map)) { |
Arnaldo Carvalho de Melo | 54da076 | 2016-09-01 10:40:57 -0300 | [diff] [blame] | 232 | if (!map->priv) { |
| 233 | if (!header_printed) { |
| 234 | pr_info("WARN: Maps only in kallsyms:\n"); |
| 235 | header_printed = true; |
| 236 | } |
Arnaldo Carvalho de Melo | 4bb7123d | 2015-05-22 11:52:22 -0300 | [diff] [blame] | 237 | map__fprintf(map, stderr); |
Arnaldo Carvalho de Melo | 54da076 | 2016-09-01 10:40:57 -0300 | [diff] [blame] | 238 | } |
Jiri Olsa | 0a4e1ae | 2012-11-10 01:46:41 +0100 | [diff] [blame] | 239 | } |
| 240 | out: |
Arnaldo Carvalho de Melo | c0aab59 | 2013-01-24 23:01:50 -0300 | [diff] [blame] | 241 | machine__exit(&kallsyms); |
| 242 | machine__exit(&vmlinux); |
Jiri Olsa | 0a4e1ae | 2012-11-10 01:46:41 +0100 | [diff] [blame] | 243 | return err; |
| 244 | } |