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 "dso.h"
8#include "map.h"
9#include "symbol.h"
10#include <internal/lib.h>
11#include "tests.h"
12#include "debug.h"
13#include "machine.h"
14
15#define UM(x) kallsyms_map->unmap_ip(kallsyms_map, (x))
16
17int test__vmlinux_matches_kallsyms(struct test *test __maybe_unused, int subtest __maybe_unused)
18{
19 int err = -1;
20 struct rb_node *nd;
21 struct symbol *sym;
22 struct map *kallsyms_map, *vmlinux_map, *map;
23 struct machine kallsyms, vmlinux;
24 struct maps *maps = machine__kernel_maps(&vmlinux);
25 u64 mem_start, mem_end;
26 bool header_printed;
27
28
29
30
31
32
33
34 machine__init(&kallsyms, "", HOST_KERNEL_ID);
35 machine__init(&vmlinux, "", HOST_KERNEL_ID);
36
37
38
39
40
41
42
43
44 if (machine__create_kernel_maps(&kallsyms) < 0) {
45 pr_debug("machine__create_kernel_maps ");
46 goto out;
47 }
48
49
50
51
52
53
54
55
56
57
58
59
60 if (machine__load_kallsyms(&kallsyms, "/proc/kallsyms") <= 0) {
61 pr_debug("dso__load_kallsyms ");
62 goto out;
63 }
64
65
66
67
68
69
70
71
72
73 kallsyms_map = machine__kernel_map(&kallsyms);
74
75
76
77
78
79
80 if (machine__create_kernel_maps(&vmlinux) < 0) {
81 pr_debug("machine__create_kernel_maps ");
82 goto out;
83 }
84
85 vmlinux_map = machine__kernel_map(&vmlinux);
86
87
88
89
90
91
92
93
94
95
96
97
98 if (machine__load_vmlinux_path(&vmlinux) <= 0) {
99 pr_debug("Couldn't find a vmlinux that matches the kernel running on this machine, skipping test\n");
100 err = TEST_SKIP;
101 goto out;
102 }
103
104 err = 0;
105
106
107
108
109
110
111
112 map__for_each_symbol(vmlinux_map, sym, nd) {
113 struct symbol *pair, *first_pair;
114
115 sym = rb_entry(nd, struct symbol, rb_node);
116
117 if (sym->start == sym->end)
118 continue;
119
120 mem_start = vmlinux_map->unmap_ip(vmlinux_map, sym->start);
121 mem_end = vmlinux_map->unmap_ip(vmlinux_map, sym->end);
122
123 first_pair = machine__find_kernel_symbol(&kallsyms, mem_start, NULL);
124 pair = first_pair;
125
126 if (pair && UM(pair->start) == mem_start) {
127next_pair:
128 if (arch__compare_symbol_names(sym->name, pair->name) == 0) {
129
130
131
132
133
134
135
136
137
138 s64 skew = mem_end - UM(pair->end);
139 if (llabs(skew) >= page_size)
140 pr_debug("WARN: %#" PRIx64 ": diff end addr for %s v: %#" PRIx64 " k: %#" PRIx64 "\n",
141 mem_start, sym->name, mem_end,
142 UM(pair->end));
143
144
145
146
147
148
149
150 continue;
151 } else {
152 pair = machine__find_kernel_symbol_by_name(&kallsyms, sym->name, NULL);
153 if (pair) {
154 if (UM(pair->start) == mem_start)
155 goto next_pair;
156
157 pr_debug("WARN: %#" PRIx64 ": diff name v: %s k: %s\n",
158 mem_start, sym->name, pair->name);
159 } else {
160 pr_debug("WARN: %#" PRIx64 ": diff name v: %s k: %s\n",
161 mem_start, sym->name, first_pair->name);
162 }
163
164 continue;
165 }
166 } else if (mem_start == kallsyms.vmlinux_map->end) {
167
168
169
170
171 continue;
172 } else {
173 pr_debug("ERR : %#" PRIx64 ": %s not on kallsyms\n",
174 mem_start, sym->name);
175 }
176
177 err = -1;
178 }
179
180 if (verbose <= 0)
181 goto out;
182
183 header_printed = false;
184
185 maps__for_each_entry(maps, map) {
186 struct map *
187
188
189
190
191
192
193 pair = maps__find_by_name(&kallsyms.kmaps, (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 maps__for_each_entry(maps, 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 = maps__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 maps__for_each_entry(maps, 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