1
2#include <linux/compiler.h>
3#include <linux/rbtree.h>
4#include <inttypes.h>
5#include <string.h>
6#include <stdlib.h>
7#include "map.h"
8#include "symbol.h"
9#include "util.h"
10#include "tests.h"
11#include "debug.h"
12#include "machine.h"
13
14#define UM(x) kallsyms_map->unmap_ip(kallsyms_map, (x))
15
16int test__vmlinux_matches_kallsyms(struct test *test __maybe_unused, int subtest __maybe_unused)
17{
18 int err = -1;
19 struct rb_node *nd;
20 struct symbol *sym;
21 struct map *kallsyms_map, *vmlinux_map, *map;
22 struct machine kallsyms, vmlinux;
23 struct maps *maps = machine__kernel_maps(&vmlinux);
24 u64 mem_start, mem_end;
25 bool header_printed;
26
27
28
29
30
31
32
33 machine__init(&kallsyms, "", HOST_KERNEL_ID);
34 machine__init(&vmlinux, "", HOST_KERNEL_ID);
35
36
37
38
39
40
41
42
43 if (machine__create_kernel_maps(&kallsyms) < 0) {
44 pr_debug("machine__create_kernel_maps ");
45 goto out;
46 }
47
48
49
50
51
52
53
54
55
56
57
58
59 if (machine__load_kallsyms(&kallsyms, "/proc/kallsyms") <= 0) {
60 pr_debug("dso__load_kallsyms ");
61 goto out;
62 }
63
64
65
66
67
68
69
70
71
72 kallsyms_map = machine__kernel_map(&kallsyms);
73
74
75
76
77
78
79 if (machine__create_kernel_maps(&vmlinux) < 0) {
80 pr_debug("machine__create_kernel_maps ");
81 goto out;
82 }
83
84 vmlinux_map = machine__kernel_map(&vmlinux);
85
86
87
88
89
90
91
92
93
94
95
96
97 if (machine__load_vmlinux_path(&vmlinux) <= 0) {
98 pr_debug("Couldn't find a vmlinux that matches the kernel running on this machine, skipping test\n");
99 err = TEST_SKIP;
100 goto out;
101 }
102
103 err = 0;
104
105
106
107
108
109
110
111 map__for_each_symbol(vmlinux_map, sym, nd) {
112 struct symbol *pair, *first_pair;
113
114 sym = rb_entry(nd, struct symbol, rb_node);
115
116 if (sym->start == sym->end)
117 continue;
118
119 mem_start = vmlinux_map->unmap_ip(vmlinux_map, sym->start);
120 mem_end = vmlinux_map->unmap_ip(vmlinux_map, sym->end);
121
122 first_pair = machine__find_kernel_symbol(&kallsyms, mem_start, NULL);
123 pair = first_pair;
124
125 if (pair && UM(pair->start) == mem_start) {
126next_pair:
127 if (arch__compare_symbol_names(sym->name, pair->name) == 0) {
128
129
130
131
132
133
134
135
136
137 s64 skew = mem_end - UM(pair->end);
138 if (llabs(skew) >= page_size)
139 pr_debug("WARN: %#" PRIx64 ": diff end addr for %s v: %#" PRIx64 " k: %#" PRIx64 "\n",
140 mem_start, sym->name, mem_end,
141 UM(pair->end));
142
143
144
145
146
147
148
149 continue;
150 } else {
151 pair = machine__find_kernel_symbol_by_name(&kallsyms, sym->name, NULL);
152 if (pair) {
153 if (UM(pair->start) == mem_start)
154 goto next_pair;
155
156 pr_debug("WARN: %#" PRIx64 ": diff name v: %s k: %s\n",
157 mem_start, sym->name, pair->name);
158 } else {
159 pr_debug("WARN: %#" PRIx64 ": diff name v: %s k: %s\n",
160 mem_start, sym->name, first_pair->name);
161 }
162
163 continue;
164 }
165 } else if (mem_start == kallsyms.vmlinux_map->end) {
166
167
168
169
170 continue;
171 } else {
172 pr_debug("ERR : %#" PRIx64 ": %s not on kallsyms\n",
173 mem_start, sym->name);
174 }
175
176 err = -1;
177 }
178
179 if (verbose <= 0)
180 goto out;
181
182 header_printed = false;
183
184 for (map = maps__first(maps); map; map = map__next(map)) {
185 struct map *
186
187
188
189
190
191
192 pair = map_groups__find_by_name(&kallsyms.kmaps,
193 (map->dso->kernel ?
194 map->dso->short_name :
195 map->dso->name));
196 if (pair) {
197 pair->priv = 1;
198 } else {
199 if (!header_printed) {
200 pr_info("WARN: Maps only in vmlinux:\n");
201 header_printed = true;
202 }
203 map__fprintf(map, stderr);
204 }
205 }
206
207 header_printed = false;
208
209 for (map = maps__first(maps); map; map = map__next(map)) {
210 struct map *pair;
211
212 mem_start = vmlinux_map->unmap_ip(vmlinux_map, map->start);
213 mem_end = vmlinux_map->unmap_ip(vmlinux_map, map->end);
214
215 pair = map_groups__find(&kallsyms.kmaps, mem_start);
216 if (pair == NULL || pair->priv)
217 continue;
218
219 if (pair->start == mem_start) {
220 if (!header_printed) {
221 pr_info("WARN: Maps in vmlinux with a different name in kallsyms:\n");
222 header_printed = true;
223 }
224
225 pr_info("WARN: %" PRIx64 "-%" PRIx64 " %" PRIx64 " %s in kallsyms as",
226 map->start, map->end, map->pgoff, map->dso->name);
227 if (mem_end != pair->end)
228 pr_info(":\nWARN: *%" PRIx64 "-%" PRIx64 " %" PRIx64,
229 pair->start, pair->end, pair->pgoff);
230 pr_info(" %s\n", pair->dso->name);
231 pair->priv = 1;
232 }
233 }
234
235 header_printed = false;
236
237 maps = machine__kernel_maps(&kallsyms);
238
239 for (map = maps__first(maps); map; map = map__next(map)) {
240 if (!map->priv) {
241 if (!header_printed) {
242 pr_info("WARN: Maps only in kallsyms:\n");
243 header_printed = true;
244 }
245 map__fprintf(map, stderr);
246 }
247 }
248out:
249 machine__exit(&kallsyms);
250 machine__exit(&vmlinux);
251 return err;
252}
253