]>
Commit | Line | Data |
---|---|---|
708624a4 GSB |
1 | /* |
2 | * libkmod - interface to kernel module operations | |
3 | * | |
e6b0e49b | 4 | * Copyright (C) 2011-2013 ProFUSION embedded systems |
708624a4 GSB |
5 | * |
6 | * This library is free software; you can redistribute it and/or | |
7 | * modify it under the terms of the GNU Lesser General Public | |
8 | * License as published by the Free Software Foundation; either | |
9 | * version 2.1 of the License, or (at your option) any later version. | |
10 | * | |
11 | * This library is distributed in the hope that it will be useful, | |
12 | * but WITHOUT ANY WARRANTY; without even the implied warranty of | |
13 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU | |
14 | * Lesser General Public License for more details. | |
15 | * | |
16 | * You should have received a copy of the GNU Lesser General Public | |
dea2dfee | 17 | * License along with this library; if not, see <http://www.gnu.org/licenses/>. |
708624a4 GSB |
18 | */ |
19 | ||
c2e4286b | 20 | #include <assert.h> |
708624a4 | 21 | #include <elf.h> |
c2e4286b | 22 | #include <errno.h> |
708624a4 GSB |
23 | #include <stdlib.h> |
24 | #include <string.h> | |
708624a4 | 25 | |
96573a02 LDM |
26 | #include <shared/util.h> |
27 | ||
708624a4 | 28 | #include "libkmod.h" |
83b855a6 | 29 | #include "libkmod-internal.h" |
708624a4 GSB |
30 | |
31 | enum kmod_elf_class { | |
32 | KMOD_ELF_32 = (1 << 1), | |
33 | KMOD_ELF_64 = (1 << 2), | |
34 | KMOD_ELF_LSB = (1 << 3), | |
35 | KMOD_ELF_MSB = (1 << 4) | |
36 | }; | |
37 | ||
674f8590 GSB |
38 | /* as defined in module-init-tools */ |
39 | struct kmod_modversion32 { | |
40 | uint32_t crc; | |
41 | char name[64 - sizeof(uint32_t)]; | |
42 | }; | |
43 | ||
44 | struct kmod_modversion64 { | |
45 | uint64_t crc; | |
46 | char name[64 - sizeof(uint64_t)]; | |
47 | }; | |
48 | ||
708624a4 GSB |
49 | struct kmod_elf { |
50 | const uint8_t *memory; | |
51 | uint8_t *changed; | |
52 | uint64_t size; | |
53 | enum kmod_elf_class class; | |
54 | struct kmod_elf_header { | |
55 | struct { | |
56 | uint64_t offset; | |
57 | uint16_t count; | |
58 | uint16_t entry_size; | |
59 | } section; | |
60 | struct { | |
61 | uint16_t section; /* index of the strings section */ | |
62 | uint64_t size; | |
63 | uint64_t offset; | |
64 | uint32_t nameoff; /* offset in strings itself */ | |
65 | } strings; | |
674f8590 | 66 | uint16_t machine; |
708624a4 GSB |
67 | } header; |
68 | }; | |
69 | ||
70 | //#define ENABLE_ELFDBG 1 | |
71 | ||
72 | #if defined(ENABLE_LOGGING) && defined(ENABLE_ELFDBG) | |
73 | #define ELFDBG(elf, ...) \ | |
87beacc9 | 74 | _elf_dbg(elf, __FILE__, __LINE__, __func__, __VA_ARGS__); |
708624a4 GSB |
75 | |
76 | static inline void _elf_dbg(const struct kmod_elf *elf, const char *fname, unsigned line, const char *func, const char *fmt, ...) | |
77 | { | |
78 | va_list args; | |
79 | ||
80 | fprintf(stderr, "ELFDBG-%d%c: %s:%u %s() ", | |
81 | (elf->class & KMOD_ELF_32) ? 32 : 64, | |
82 | (elf->class & KMOD_ELF_MSB) ? 'M' : 'L', | |
83 | fname, line, func); | |
84 | va_start(args, fmt); | |
85 | vfprintf(stderr, fmt, args); | |
86 | va_end(args); | |
87 | } | |
88 | #else | |
89 | #define ELFDBG(elf, ...) | |
90 | #endif | |
91 | ||
92 | ||
93 | static int elf_identify(const void *memory, uint64_t size) | |
94 | { | |
95 | const uint8_t *p = memory; | |
96 | int class = 0; | |
97 | ||
98 | if (size <= EI_NIDENT || memcmp(p, ELFMAG, SELFMAG) != 0) | |
99 | return -ENOEXEC; | |
100 | ||
101 | switch (p[EI_CLASS]) { | |
102 | case ELFCLASS32: | |
103 | if (size <= sizeof(Elf32_Ehdr)) | |
104 | return -EINVAL; | |
105 | class |= KMOD_ELF_32; | |
106 | break; | |
107 | case ELFCLASS64: | |
108 | if (size <= sizeof(Elf64_Ehdr)) | |
109 | return -EINVAL; | |
110 | class |= KMOD_ELF_64; | |
111 | break; | |
112 | default: | |
113 | return -EINVAL; | |
114 | } | |
115 | ||
116 | switch (p[EI_DATA]) { | |
117 | case ELFDATA2LSB: | |
118 | class |= KMOD_ELF_LSB; | |
119 | break; | |
120 | case ELFDATA2MSB: | |
121 | class |= KMOD_ELF_MSB; | |
122 | break; | |
123 | default: | |
124 | return -EINVAL; | |
125 | } | |
126 | ||
127 | return class; | |
128 | } | |
129 | ||
130 | static inline uint64_t elf_get_uint(const struct kmod_elf *elf, uint64_t offset, uint16_t size) | |
131 | { | |
132 | const uint8_t *p; | |
133 | uint64_t ret = 0; | |
134 | size_t i; | |
135 | ||
136 | assert(size <= sizeof(uint64_t)); | |
137 | assert(offset + size <= elf->size); | |
138 | if (offset + size > elf->size) { | |
139 | ELFDBG(elf, "out of bounds: %"PRIu64" + %"PRIu16" = %"PRIu64"> %"PRIu64" (ELF size)\n", | |
140 | offset, size, offset + size, elf->size); | |
141 | return (uint64_t)-1; | |
142 | } | |
143 | ||
144 | p = elf->memory + offset; | |
145 | if (elf->class & KMOD_ELF_MSB) { | |
146 | for (i = 0; i < size; i++) | |
fc8e58ba | 147 | ret = (ret << 8) | p[i]; |
708624a4 GSB |
148 | } else { |
149 | for (i = 1; i <= size; i++) | |
150 | ret = (ret << 8) | p[size - i]; | |
151 | } | |
152 | ||
153 | ELFDBG(elf, "size=%"PRIu16" offset=%"PRIu64" value=%"PRIu64"\n", | |
154 | size, offset, ret); | |
155 | ||
156 | return ret; | |
157 | } | |
158 | ||
159 | static inline int elf_set_uint(struct kmod_elf *elf, uint64_t offset, uint64_t size, uint64_t value) | |
160 | { | |
161 | uint8_t *p; | |
162 | size_t i; | |
163 | ||
164 | ELFDBG(elf, "size=%"PRIu16" offset=%"PRIu64" value=%"PRIu64" write memory=%p\n", | |
165 | size, offset, value, elf->changed); | |
166 | ||
167 | assert(size <= sizeof(uint64_t)); | |
168 | assert(offset + size <= elf->size); | |
169 | if (offset + size > elf->size) { | |
170 | ELFDBG(elf, "out of bounds: %"PRIu64" + %"PRIu16" = %"PRIu64"> %"PRIu64" (ELF size)\n", | |
171 | offset, size, offset + size, elf->size); | |
172 | return -1; | |
173 | } | |
174 | ||
175 | if (elf->changed == NULL) { | |
176 | elf->changed = malloc(elf->size); | |
177 | if (elf->changed == NULL) | |
178 | return -errno; | |
179 | memcpy(elf->changed, elf->memory, elf->size); | |
180 | elf->memory = elf->changed; | |
181 | ELFDBG(elf, "copied memory to allow writing.\n"); | |
182 | } | |
183 | ||
184 | p = elf->changed + offset; | |
185 | if (elf->class & KMOD_ELF_MSB) { | |
186 | for (i = 1; i <= size; i++) { | |
187 | p[size - i] = value & 0xff; | |
188 | value = (value & 0xffffffffffffff00) >> 8; | |
189 | } | |
190 | } else { | |
191 | for (i = 0; i < size; i++) { | |
192 | p[i] = value & 0xff; | |
193 | value = (value & 0xffffffffffffff00) >> 8; | |
194 | } | |
195 | } | |
196 | ||
197 | return 0; | |
198 | } | |
199 | ||
200 | static inline const void *elf_get_mem(const struct kmod_elf *elf, uint64_t offset) | |
201 | { | |
202 | assert(offset < elf->size); | |
203 | if (offset >= elf->size) { | |
204 | ELFDBG(elf, "out-of-bounds: %"PRIu64" >= %"PRIu64" (ELF size)\n", | |
205 | offset, elf->size); | |
206 | return NULL; | |
207 | } | |
208 | return elf->memory + offset; | |
209 | } | |
210 | ||
211 | static inline const void *elf_get_section_header(const struct kmod_elf *elf, uint16_t idx) | |
212 | { | |
213 | assert(idx != SHN_UNDEF); | |
214 | assert(idx < elf->header.section.count); | |
215 | if (idx == SHN_UNDEF || idx >= elf->header.section.count) { | |
216 | ELFDBG(elf, "invalid section number: %"PRIu16", last=%"PRIu16"\n", | |
217 | idx, elf->header.section.count); | |
218 | return NULL; | |
219 | } | |
220 | return elf_get_mem(elf, elf->header.section.offset + | |
d98f2d32 | 221 | (uint64_t)(idx * elf->header.section.entry_size)); |
708624a4 GSB |
222 | } |
223 | ||
224 | static inline int elf_get_section_info(const struct kmod_elf *elf, uint16_t idx, uint64_t *offset, uint64_t *size, uint32_t *nameoff) | |
225 | { | |
226 | const uint8_t *p = elf_get_section_header(elf, idx); | |
227 | uint64_t min_size, off = p - elf->memory; | |
228 | ||
229 | if (p == NULL) { | |
230 | ELFDBG(elf, "no section at %"PRIu16"\n", idx); | |
231 | *offset = 0; | |
232 | *size = 0; | |
233 | *nameoff = 0; | |
234 | return -EINVAL; | |
235 | } | |
236 | ||
237 | #define READV(field) \ | |
238 | elf_get_uint(elf, off + offsetof(typeof(*hdr), field), sizeof(hdr->field)) | |
239 | ||
240 | if (elf->class & KMOD_ELF_32) { | |
9e2eadb1 | 241 | const Elf32_Shdr *hdr _unused_ = (const Elf32_Shdr *)p; |
708624a4 GSB |
242 | *size = READV(sh_size); |
243 | *offset = READV(sh_offset); | |
244 | *nameoff = READV(sh_name); | |
245 | } else { | |
9e2eadb1 | 246 | const Elf64_Shdr *hdr _unused_ = (const Elf64_Shdr *)p; |
708624a4 GSB |
247 | *size = READV(sh_size); |
248 | *offset = READV(sh_offset); | |
249 | *nameoff = READV(sh_name); | |
250 | } | |
251 | #undef READV | |
252 | ||
6684102c LDM |
253 | if (addu64_overflow(*offset, *size, &min_size) |
254 | || min_size > elf->size) { | |
708624a4 GSB |
255 | ELFDBG(elf, "out-of-bounds: %"PRIu64" >= %"PRIu64" (ELF size)\n", |
256 | min_size, elf->size); | |
257 | return -EINVAL; | |
258 | } | |
259 | ||
260 | ELFDBG(elf, "section=%"PRIu16" is: offset=%"PRIu64" size=%"PRIu64" nameoff=%"PRIu32"\n", | |
261 | idx, *offset, *size, *nameoff); | |
262 | ||
263 | return 0; | |
264 | } | |
265 | ||
266 | static const char *elf_get_strings_section(const struct kmod_elf *elf, uint64_t *size) | |
267 | { | |
268 | *size = elf->header.strings.size; | |
269 | return elf_get_mem(elf, elf->header.strings.offset); | |
270 | } | |
271 | ||
272 | struct kmod_elf *kmod_elf_new(const void *memory, off_t size) | |
273 | { | |
274 | struct kmod_elf *elf; | |
249dc590 TS |
275 | uint64_t min_size; |
276 | size_t shdrs_size, shdr_size; | |
708624a4 GSB |
277 | int class; |
278 | ||
a20a37c3 LDM |
279 | assert_cc(sizeof(uint16_t) == sizeof(Elf32_Half)); |
280 | assert_cc(sizeof(uint16_t) == sizeof(Elf64_Half)); | |
281 | assert_cc(sizeof(uint32_t) == sizeof(Elf32_Word)); | |
282 | assert_cc(sizeof(uint32_t) == sizeof(Elf64_Word)); | |
708624a4 GSB |
283 | |
284 | class = elf_identify(memory, size); | |
285 | if (class < 0) { | |
286 | errno = -class; | |
287 | return NULL; | |
288 | } | |
289 | ||
290 | elf = malloc(sizeof(struct kmod_elf)); | |
291 | if (elf == NULL) { | |
292 | return NULL; | |
293 | } | |
294 | ||
295 | elf->memory = memory; | |
296 | elf->changed = NULL; | |
297 | elf->size = size; | |
298 | elf->class = class; | |
299 | ||
300 | #define READV(field) \ | |
301 | elf_get_uint(elf, offsetof(typeof(*hdr), field), sizeof(hdr->field)) | |
302 | ||
303 | #define LOAD_HEADER \ | |
304 | elf->header.section.offset = READV(e_shoff); \ | |
305 | elf->header.section.count = READV(e_shnum); \ | |
306 | elf->header.section.entry_size = READV(e_shentsize); \ | |
674f8590 GSB |
307 | elf->header.strings.section = READV(e_shstrndx); \ |
308 | elf->header.machine = READV(e_machine) | |
708624a4 | 309 | if (elf->class & KMOD_ELF_32) { |
9e2eadb1 | 310 | const Elf32_Ehdr *hdr _unused_ = elf_get_mem(elf, 0); |
708624a4 | 311 | LOAD_HEADER; |
708624a4 GSB |
312 | shdr_size = sizeof(Elf32_Shdr); |
313 | } else { | |
9e2eadb1 | 314 | const Elf64_Ehdr *hdr _unused_ = elf_get_mem(elf, 0); |
708624a4 | 315 | LOAD_HEADER; |
708624a4 GSB |
316 | shdr_size = sizeof(Elf64_Shdr); |
317 | } | |
318 | #undef LOAD_HEADER | |
319 | #undef READV | |
320 | ||
321 | ELFDBG(elf, "section: offset=%"PRIu64" count=%"PRIu16" entry_size=%"PRIu16" strings index=%"PRIu16"\n", | |
322 | elf->header.section.offset, | |
323 | elf->header.section.count, | |
324 | elf->header.section.entry_size, | |
325 | elf->header.strings.section); | |
326 | ||
327 | if (elf->header.section.entry_size != shdr_size) { | |
328 | ELFDBG(elf, "unexpected section entry size: %"PRIu16", expected %"PRIu16"\n", | |
329 | elf->header.section.entry_size, shdr_size); | |
330 | goto invalid; | |
331 | } | |
249dc590 TS |
332 | shdrs_size = shdr_size * elf->header.section.count; |
333 | if (addu64_overflow(shdrs_size, elf->header.section.offset, &min_size) | |
334 | || min_size > elf->size) { | |
708624a4 GSB |
335 | ELFDBG(elf, "file is too short to hold sections\n"); |
336 | goto invalid; | |
337 | } | |
338 | ||
339 | if (elf_get_section_info(elf, elf->header.strings.section, | |
340 | &elf->header.strings.offset, | |
341 | &elf->header.strings.size, | |
342 | &elf->header.strings.nameoff) < 0) { | |
343 | ELFDBG(elf, "could not get strings section\n"); | |
344 | goto invalid; | |
345 | } else { | |
346 | uint64_t slen; | |
347 | const char *s = elf_get_strings_section(elf, &slen); | |
348 | if (slen == 0 || s[slen - 1] != '\0') { | |
349 | ELFDBG(elf, "strings section does not ends with \\0\n"); | |
350 | goto invalid; | |
351 | } | |
352 | } | |
353 | ||
354 | return elf; | |
355 | ||
356 | invalid: | |
357 | free(elf); | |
358 | errno = EINVAL; | |
359 | return NULL; | |
360 | } | |
361 | ||
362 | void kmod_elf_unref(struct kmod_elf *elf) | |
363 | { | |
364 | free(elf->changed); | |
365 | free(elf); | |
366 | } | |
367 | ||
368 | const void *kmod_elf_get_memory(const struct kmod_elf *elf) | |
369 | { | |
370 | return elf->memory; | |
371 | } | |
372 | ||
a4578669 LDM |
373 | static int elf_find_section(const struct kmod_elf *elf, const char *section) |
374 | { | |
375 | uint64_t nameslen; | |
376 | const char *names = elf_get_strings_section(elf, &nameslen); | |
377 | uint16_t i; | |
378 | ||
379 | for (i = 1; i < elf->header.section.count; i++) { | |
380 | uint64_t off, size; | |
381 | uint32_t nameoff; | |
382 | const char *n; | |
383 | int err = elf_get_section_info(elf, i, &off, &size, &nameoff); | |
384 | if (err < 0) | |
385 | continue; | |
386 | if (nameoff >= nameslen) | |
387 | continue; | |
388 | n = names + nameoff; | |
389 | if (!streq(section, n)) | |
390 | continue; | |
391 | ||
392 | return i; | |
393 | } | |
394 | ||
395 | return -ENOENT; | |
396 | } | |
397 | ||
ea17e2b0 | 398 | int kmod_elf_get_section(const struct kmod_elf *elf, const char *section, const void **buf, uint64_t *buf_size) |
708624a4 GSB |
399 | { |
400 | uint64_t nameslen; | |
401 | const char *names = elf_get_strings_section(elf, &nameslen); | |
402 | uint16_t i; | |
403 | ||
404 | *buf = NULL; | |
405 | *buf_size = 0; | |
406 | ||
407 | for (i = 1; i < elf->header.section.count; i++) { | |
408 | uint64_t off, size; | |
409 | uint32_t nameoff; | |
410 | const char *n; | |
411 | int err = elf_get_section_info(elf, i, &off, &size, &nameoff); | |
412 | if (err < 0) | |
413 | continue; | |
414 | if (nameoff >= nameslen) | |
415 | continue; | |
416 | n = names + nameoff; | |
417 | if (!streq(section, n)) | |
418 | continue; | |
419 | ||
420 | *buf = elf_get_mem(elf, off); | |
421 | *buf_size = size; | |
422 | return 0; | |
423 | } | |
424 | ||
425 | return -ENOENT; | |
426 | } | |
427 | ||
428 | /* array will be allocated with strings in a single malloc, just free *array */ | |
429 | int kmod_elf_get_strings(const struct kmod_elf *elf, const char *section, char ***array) | |
430 | { | |
a969376f LFSM |
431 | size_t i, j, count; |
432 | uint64_t size; | |
708624a4 GSB |
433 | const void *buf; |
434 | const char *strings; | |
f8fa525c LDM |
435 | char *s, **a; |
436 | int err; | |
708624a4 GSB |
437 | |
438 | *array = NULL; | |
439 | ||
440 | err = kmod_elf_get_section(elf, section, &buf, &size); | |
441 | if (err < 0) | |
442 | return err; | |
052656f5 | 443 | |
708624a4 GSB |
444 | strings = buf; |
445 | if (strings == NULL || size == 0) | |
446 | return 0; | |
447 | ||
448 | /* skip zero padding */ | |
449 | while (strings[0] == '\0' && size > 1) { | |
450 | strings++; | |
451 | size--; | |
452 | } | |
052656f5 | 453 | |
708624a4 GSB |
454 | if (size <= 1) |
455 | return 0; | |
456 | ||
76b8031b LDM |
457 | for (i = 0, count = 0; i < size; ) { |
458 | if (strings[i] != '\0') { | |
459 | i++; | |
4f0f0e75 | 460 | continue; |
76b8031b LDM |
461 | } |
462 | ||
463 | while (strings[i] == '\0' && i < size) | |
464 | i++; | |
4f0f0e75 | 465 | |
4f0f0e75 | 466 | count++; |
708624a4 | 467 | } |
052656f5 | 468 | |
708624a4 GSB |
469 | if (strings[i - 1] != '\0') |
470 | count++; | |
471 | ||
3267026e | 472 | *array = a = malloc(size + 1 + sizeof(char *) * (count + 1)); |
708624a4 GSB |
473 | if (*array == NULL) |
474 | return -errno; | |
475 | ||
f8fa525c LDM |
476 | s = (char *)(a + count + 1); |
477 | memcpy(s, strings, size); | |
478 | ||
479 | /* make sure the last string is NULL-terminated */ | |
480 | s[size] = '\0'; | |
3267026e | 481 | a[count] = NULL; |
f8fa525c | 482 | a[0] = s; |
052656f5 | 483 | |
76b8031b LDM |
484 | for (i = 0, j = 1; j < count && i < size; ) { |
485 | if (s[i] != '\0') { | |
486 | i++; | |
f8fa525c | 487 | continue; |
76b8031b LDM |
488 | } |
489 | ||
490 | while (strings[i] == '\0' && i < size) | |
491 | i++; | |
052656f5 | 492 | |
76b8031b | 493 | a[j] = &s[i]; |
f8fa525c | 494 | j++; |
708624a4 GSB |
495 | } |
496 | ||
497 | return count; | |
498 | } | |
499 | ||
500 | /* array will be allocated with strings in a single malloc, just free *array */ | |
501 | int kmod_elf_get_modversions(const struct kmod_elf *elf, struct kmod_modversion **array) | |
502 | { | |
a969376f LFSM |
503 | size_t off, offcrc, slen; |
504 | uint64_t size; | |
708624a4 GSB |
505 | struct kmod_modversion *a; |
506 | const void *buf; | |
507 | char *itr; | |
508 | int i, count, err; | |
58b7191c LDM |
509 | #define MODVERSION_SEC_SIZE (sizeof(struct kmod_modversion64)) |
510 | ||
a20a37c3 | 511 | assert_cc(sizeof(struct kmod_modversion64) == |
58b7191c | 512 | sizeof(struct kmod_modversion32)); |
708624a4 | 513 | |
fea655dc | 514 | if (elf->class & KMOD_ELF_32) |
51c409b4 LDM |
515 | offcrc = sizeof(uint32_t); |
516 | else | |
517 | offcrc = sizeof(uint64_t); | |
518 | ||
708624a4 GSB |
519 | *array = NULL; |
520 | ||
521 | err = kmod_elf_get_section(elf, "__versions", &buf, &size); | |
522 | if (err < 0) | |
523 | return err; | |
58b7191c | 524 | |
708624a4 GSB |
525 | if (buf == NULL || size == 0) |
526 | return 0; | |
527 | ||
58b7191c | 528 | if (size % MODVERSION_SEC_SIZE != 0) |
708624a4 | 529 | return -EINVAL; |
58b7191c LDM |
530 | |
531 | count = size / MODVERSION_SEC_SIZE; | |
708624a4 GSB |
532 | |
533 | off = (const uint8_t *)buf - elf->memory; | |
534 | slen = 0; | |
51c409b4 | 535 | |
58b7191c | 536 | for (i = 0; i < count; i++, off += MODVERSION_SEC_SIZE) { |
51c409b4 LDM |
537 | const char *symbol = elf_get_mem(elf, off + offcrc); |
538 | ||
1c585905 GSB |
539 | if (symbol[0] == '.') |
540 | symbol++; | |
51c409b4 | 541 | |
708624a4 GSB |
542 | slen += strlen(symbol) + 1; |
543 | } | |
544 | ||
545 | *array = a = malloc(sizeof(struct kmod_modversion) * count + slen); | |
546 | if (*array == NULL) | |
547 | return -errno; | |
548 | ||
549 | itr = (char *)(a + count); | |
550 | off = (const uint8_t *)buf - elf->memory; | |
51c409b4 | 551 | |
58b7191c | 552 | for (i = 0; i < count; i++, off += MODVERSION_SEC_SIZE) { |
51c409b4 LDM |
553 | uint64_t crc = elf_get_uint(elf, off, offcrc); |
554 | const char *symbol = elf_get_mem(elf, off + offcrc); | |
708624a4 | 555 | size_t symbollen; |
51c409b4 | 556 | |
1c585905 GSB |
557 | if (symbol[0] == '.') |
558 | symbol++; | |
708624a4 GSB |
559 | |
560 | a[i].crc = crc; | |
674f8590 | 561 | a[i].bind = KMOD_SYMBOL_UNDEF; |
708624a4 GSB |
562 | a[i].symbol = itr; |
563 | symbollen = strlen(symbol) + 1; | |
564 | memcpy(itr, symbol, symbollen); | |
565 | itr += symbollen; | |
566 | } | |
567 | ||
568 | return count; | |
569 | } | |
570 | ||
571 | int kmod_elf_strip_section(struct kmod_elf *elf, const char *section) | |
572 | { | |
a4578669 | 573 | uint64_t off, size; |
708624a4 | 574 | const void *buf; |
a4578669 LDM |
575 | int idx = elf_find_section(elf, section); |
576 | uint64_t val; | |
708624a4 | 577 | |
a4578669 LDM |
578 | if (idx < 0) |
579 | return idx; | |
580 | ||
581 | buf = elf_get_section_header(elf, idx); | |
708624a4 GSB |
582 | off = (const uint8_t *)buf - elf->memory; |
583 | ||
708624a4 | 584 | if (elf->class & KMOD_ELF_32) { |
a4578669 LDM |
585 | off += offsetof(Elf32_Shdr, sh_flags); |
586 | size = sizeof(((Elf32_Shdr *)buf)->sh_flags); | |
708624a4 | 587 | } else { |
a4578669 LDM |
588 | off += offsetof(Elf64_Shdr, sh_flags); |
589 | size = sizeof(((Elf64_Shdr *)buf)->sh_flags); | |
708624a4 | 590 | } |
a4578669 LDM |
591 | |
592 | val = elf_get_uint(elf, off, size); | |
593 | val &= ~(uint64_t)SHF_ALLOC; | |
594 | ||
595 | return elf_set_uint(elf, off, size, val); | |
708624a4 GSB |
596 | } |
597 | ||
598 | int kmod_elf_strip_vermagic(struct kmod_elf *elf) | |
599 | { | |
600 | uint64_t i, size; | |
601 | const void *buf; | |
602 | const char *strings; | |
603 | int err; | |
604 | ||
605 | err = kmod_elf_get_section(elf, ".modinfo", &buf, &size); | |
606 | if (err < 0) | |
607 | return err; | |
608 | strings = buf; | |
609 | if (strings == NULL || size == 0) | |
610 | return 0; | |
611 | ||
612 | /* skip zero padding */ | |
613 | while (strings[0] == '\0' && size > 1) { | |
614 | strings++; | |
615 | size--; | |
616 | } | |
617 | if (size <= 1) | |
618 | return 0; | |
619 | ||
620 | for (i = 0; i < size; i++) { | |
621 | const char *s; | |
622 | size_t off, len; | |
623 | ||
624 | if (strings[i] == '\0') | |
625 | continue; | |
626 | if (i + 1 >= size) | |
627 | continue; | |
628 | ||
629 | s = strings + i; | |
630 | len = sizeof("vermagic=") - 1; | |
631 | if (i + len >= size) | |
632 | continue; | |
633 | if (strncmp(s, "vermagic=", len) != 0) { | |
634 | i += strlen(s); | |
635 | continue; | |
636 | } | |
708624a4 GSB |
637 | off = (const uint8_t *)s - elf->memory; |
638 | ||
639 | if (elf->changed == NULL) { | |
640 | elf->changed = malloc(elf->size); | |
641 | if (elf->changed == NULL) | |
642 | return -errno; | |
643 | memcpy(elf->changed, elf->memory, elf->size); | |
644 | elf->memory = elf->changed; | |
645 | ELFDBG(elf, "copied memory to allow writing.\n"); | |
646 | } | |
647 | ||
648 | len = strlen(s); | |
649 | ELFDBG(elf, "clear .modinfo vermagic \"%s\" (%zd bytes)\n", | |
650 | s, len); | |
651 | memset(elf->changed + off, '\0', len); | |
652 | return 0; | |
653 | } | |
654 | ||
655 | ELFDBG(elf, "no vermagic found in .modinfo\n"); | |
656 | return -ENOENT; | |
657 | } | |
45e6db9c GSB |
658 | |
659 | ||
660 | static int kmod_elf_get_symbols_symtab(const struct kmod_elf *elf, struct kmod_modversion **array) | |
661 | { | |
662 | uint64_t i, last, size; | |
663 | const void *buf; | |
664 | const char *strings; | |
665 | char *itr; | |
666 | struct kmod_modversion *a; | |
667 | int count, err; | |
668 | ||
669 | *array = NULL; | |
670 | ||
671 | err = kmod_elf_get_section(elf, "__ksymtab_strings", &buf, &size); | |
672 | if (err < 0) | |
673 | return err; | |
674 | strings = buf; | |
675 | if (strings == NULL || size == 0) | |
676 | return 0; | |
677 | ||
678 | /* skip zero padding */ | |
679 | while (strings[0] == '\0' && size > 1) { | |
680 | strings++; | |
681 | size--; | |
682 | } | |
683 | if (size <= 1) | |
684 | return 0; | |
685 | ||
686 | last = 0; | |
687 | for (i = 0, count = 0; i < size; i++) { | |
688 | if (strings[i] == '\0') { | |
689 | if (last == i) { | |
690 | last = i + 1; | |
691 | continue; | |
692 | } | |
693 | count++; | |
694 | last = i + 1; | |
695 | } | |
696 | } | |
697 | if (strings[i - 1] != '\0') | |
698 | count++; | |
699 | ||
700 | *array = a = malloc(size + 1 + sizeof(struct kmod_modversion) * count); | |
701 | if (*array == NULL) | |
702 | return -errno; | |
703 | ||
704 | itr = (char *)(a + count); | |
705 | last = 0; | |
706 | for (i = 0, count = 0; i < size; i++) { | |
707 | if (strings[i] == '\0') { | |
708 | size_t slen = i - last; | |
709 | if (last == i) { | |
710 | last = i + 1; | |
711 | continue; | |
712 | } | |
713 | a[count].crc = 0; | |
674f8590 | 714 | a[count].bind = KMOD_SYMBOL_GLOBAL; |
45e6db9c GSB |
715 | a[count].symbol = itr; |
716 | memcpy(itr, strings + last, slen); | |
717 | itr[slen] = '\0'; | |
718 | itr += slen + 1; | |
719 | count++; | |
720 | last = i + 1; | |
721 | } | |
722 | } | |
723 | if (strings[i - 1] != '\0') { | |
724 | size_t slen = i - last; | |
725 | a[count].crc = 0; | |
674f8590 | 726 | a[count].bind = KMOD_SYMBOL_GLOBAL; |
45e6db9c GSB |
727 | a[count].symbol = itr; |
728 | memcpy(itr, strings + last, slen); | |
729 | itr[slen] = '\0'; | |
45e6db9c GSB |
730 | count++; |
731 | } | |
732 | ||
733 | return count; | |
734 | } | |
735 | ||
674f8590 | 736 | static inline uint8_t kmod_symbol_bind_from_elf(uint8_t elf_value) |
4b55befd GSB |
737 | { |
738 | switch (elf_value) { | |
739 | case STB_LOCAL: | |
674f8590 | 740 | return KMOD_SYMBOL_LOCAL; |
4b55befd | 741 | case STB_GLOBAL: |
674f8590 | 742 | return KMOD_SYMBOL_GLOBAL; |
4b55befd | 743 | case STB_WEAK: |
674f8590 | 744 | return KMOD_SYMBOL_WEAK; |
4b55befd | 745 | default: |
674f8590 | 746 | return KMOD_SYMBOL_NONE; |
4b55befd GSB |
747 | } |
748 | } | |
749 | ||
1e489011 YK |
750 | static uint64_t kmod_elf_resolve_crc(const struct kmod_elf *elf, uint64_t crc, uint16_t shndx) |
751 | { | |
752 | int err; | |
753 | uint64_t off, size; | |
754 | uint32_t nameoff; | |
755 | ||
756 | if (shndx == SHN_ABS || shndx == SHN_UNDEF) | |
757 | return crc; | |
758 | ||
759 | err = elf_get_section_info(elf, shndx, &off, &size, &nameoff); | |
760 | if (err < 0) { | |
761 | ELFDBG("Cound not find section index %"PRIu16" for crc", shndx); | |
762 | return (uint64_t)-1; | |
763 | } | |
764 | ||
765 | if (crc > (size - sizeof(uint32_t))) { | |
766 | ELFDBG("CRC offset %"PRIu64" is too big, section %"PRIu16" size is %"PRIu64"\n", | |
767 | crc, shndx, size); | |
768 | return (uint64_t)-1; | |
769 | } | |
770 | ||
771 | crc = elf_get_uint(elf, off + crc, sizeof(uint32_t)); | |
772 | return crc; | |
773 | } | |
774 | ||
45e6db9c GSB |
775 | /* array will be allocated with strings in a single malloc, just free *array */ |
776 | int kmod_elf_get_symbols(const struct kmod_elf *elf, struct kmod_modversion **array) | |
777 | { | |
778 | static const char crc_str[] = "__crc_"; | |
779 | static const size_t crc_strlen = sizeof(crc_str) - 1; | |
780 | uint64_t strtablen, symtablen, str_off, sym_off; | |
781 | const void *strtab, *symtab; | |
782 | struct kmod_modversion *a; | |
783 | char *itr; | |
784 | size_t slen, symlen; | |
785 | int i, count, symcount, err; | |
786 | ||
787 | err = kmod_elf_get_section(elf, ".strtab", &strtab, &strtablen); | |
788 | if (err < 0) { | |
789 | ELFDBG(elf, "no .strtab found.\n"); | |
790 | goto fallback; | |
791 | } | |
792 | ||
793 | err = kmod_elf_get_section(elf, ".symtab", &symtab, &symtablen); | |
794 | if (err < 0) { | |
795 | ELFDBG(elf, "no .symtab found.\n"); | |
796 | goto fallback; | |
797 | } | |
798 | ||
799 | if (elf->class & KMOD_ELF_32) | |
800 | symlen = sizeof(Elf32_Sym); | |
801 | else | |
802 | symlen = sizeof(Elf64_Sym); | |
803 | ||
804 | if (symtablen % symlen != 0) { | |
805 | ELFDBG(elf, "unexpected .symtab of length %"PRIu64", not multiple of %"PRIu64" as expected.\n", symtablen, symlen); | |
806 | goto fallback; | |
807 | } | |
808 | ||
809 | symcount = symtablen / symlen; | |
810 | count = 0; | |
811 | slen = 0; | |
812 | str_off = (const uint8_t *)strtab - elf->memory; | |
813 | sym_off = (const uint8_t *)symtab - elf->memory + symlen; | |
814 | for (i = 1; i < symcount; i++, sym_off += symlen) { | |
815 | const char *name; | |
816 | uint32_t name_off; | |
817 | ||
818 | #define READV(field) \ | |
819 | elf_get_uint(elf, sym_off + offsetof(typeof(*s), field),\ | |
820 | sizeof(s->field)) | |
821 | if (elf->class & KMOD_ELF_32) { | |
822 | Elf32_Sym *s; | |
823 | name_off = READV(st_name); | |
824 | } else { | |
825 | Elf64_Sym *s; | |
826 | name_off = READV(st_name); | |
827 | } | |
828 | #undef READV | |
829 | if (name_off >= strtablen) { | |
830 | ELFDBG(elf, ".strtab is %"PRIu64" bytes, but .symtab entry %d wants to access offset %"PRIu32".\n", strtablen, i, name_off); | |
831 | goto fallback; | |
832 | } | |
833 | ||
834 | name = elf_get_mem(elf, str_off + name_off); | |
835 | ||
836 | if (strncmp(name, crc_str, crc_strlen) != 0) | |
837 | continue; | |
838 | slen += strlen(name + crc_strlen) + 1; | |
839 | count++; | |
840 | } | |
841 | ||
842 | if (count == 0) | |
843 | goto fallback; | |
844 | ||
845 | *array = a = malloc(sizeof(struct kmod_modversion) * count + slen); | |
846 | if (*array == NULL) | |
847 | return -errno; | |
848 | ||
849 | itr = (char *)(a + count); | |
850 | count = 0; | |
851 | str_off = (const uint8_t *)strtab - elf->memory; | |
852 | sym_off = (const uint8_t *)symtab - elf->memory + symlen; | |
853 | for (i = 1; i < symcount; i++, sym_off += symlen) { | |
854 | const char *name; | |
855 | uint32_t name_off; | |
856 | uint64_t crc; | |
4b55befd | 857 | uint8_t info, bind; |
1e489011 | 858 | uint16_t shndx; |
45e6db9c GSB |
859 | |
860 | #define READV(field) \ | |
861 | elf_get_uint(elf, sym_off + offsetof(typeof(*s), field),\ | |
862 | sizeof(s->field)) | |
863 | if (elf->class & KMOD_ELF_32) { | |
864 | Elf32_Sym *s; | |
865 | name_off = READV(st_name); | |
866 | crc = READV(st_value); | |
4b55befd | 867 | info = READV(st_info); |
1e489011 | 868 | shndx = READV(st_shndx); |
45e6db9c GSB |
869 | } else { |
870 | Elf64_Sym *s; | |
871 | name_off = READV(st_name); | |
872 | crc = READV(st_value); | |
4b55befd | 873 | info = READV(st_info); |
1e489011 | 874 | shndx = READV(st_shndx); |
45e6db9c GSB |
875 | } |
876 | #undef READV | |
877 | name = elf_get_mem(elf, str_off + name_off); | |
878 | if (strncmp(name, crc_str, crc_strlen) != 0) | |
879 | continue; | |
880 | name += crc_strlen; | |
881 | ||
4b55befd GSB |
882 | if (elf->class & KMOD_ELF_32) |
883 | bind = ELF32_ST_BIND(info); | |
884 | else | |
885 | bind = ELF64_ST_BIND(info); | |
886 | ||
1e489011 | 887 | a[count].crc = kmod_elf_resolve_crc(elf, crc, shndx); |
674f8590 | 888 | a[count].bind = kmod_symbol_bind_from_elf(bind); |
45e6db9c GSB |
889 | a[count].symbol = itr; |
890 | slen = strlen(name); | |
891 | memcpy(itr, name, slen); | |
892 | itr[slen] = '\0'; | |
893 | itr += slen + 1; | |
894 | count++; | |
895 | } | |
896 | return count; | |
897 | ||
898 | fallback: | |
899 | ELFDBG(elf, "Falling back to __ksymtab_strings!\n"); | |
900 | return kmod_elf_get_symbols_symtab(elf, array); | |
901 | } | |
674f8590 GSB |
902 | |
903 | static int kmod_elf_crc_find(const struct kmod_elf *elf, const void *versions, uint64_t versionslen, const char *name, uint64_t *crc) | |
904 | { | |
905 | size_t verlen, crclen, off; | |
906 | uint64_t i; | |
907 | ||
908 | if (elf->class & KMOD_ELF_32) { | |
909 | struct kmod_modversion32 *mv; | |
910 | verlen = sizeof(*mv); | |
911 | crclen = sizeof(mv->crc); | |
912 | } else { | |
913 | struct kmod_modversion64 *mv; | |
914 | verlen = sizeof(*mv); | |
915 | crclen = sizeof(mv->crc); | |
916 | } | |
917 | ||
918 | off = (const uint8_t *)versions - elf->memory; | |
919 | for (i = 0; i < versionslen; i += verlen) { | |
920 | const char *symbol = elf_get_mem(elf, off + i + crclen); | |
921 | if (!streq(name, symbol)) | |
922 | continue; | |
923 | *crc = elf_get_uint(elf, off + i, crclen); | |
924 | return i / verlen; | |
925 | } | |
926 | ||
927 | ELFDBG(elf, "could not find crc for symbol '%s'\n", name); | |
928 | *crc = 0; | |
929 | return -1; | |
930 | } | |
931 | ||
932 | /* from module-init-tools:elfops_core.c */ | |
933 | #ifndef STT_REGISTER | |
934 | #define STT_REGISTER 13 /* Global register reserved to app. */ | |
935 | #endif | |
936 | ||
937 | /* array will be allocated with strings in a single malloc, just free *array */ | |
938 | int kmod_elf_get_dependency_symbols(const struct kmod_elf *elf, struct kmod_modversion **array) | |
939 | { | |
940 | uint64_t versionslen, strtablen, symtablen, str_off, sym_off, ver_off; | |
941 | const void *versions, *strtab, *symtab; | |
942 | struct kmod_modversion *a; | |
943 | char *itr; | |
944 | size_t slen, verlen, symlen, crclen; | |
945 | int i, count, symcount, vercount, err; | |
946 | bool handle_register_symbols; | |
947 | uint8_t *visited_versions; | |
948 | uint64_t *symcrcs; | |
949 | ||
950 | err = kmod_elf_get_section(elf, "__versions", &versions, &versionslen); | |
951 | if (err < 0) { | |
952 | versions = NULL; | |
953 | versionslen = 0; | |
954 | verlen = 0; | |
955 | crclen = 0; | |
956 | } else { | |
957 | if (elf->class & KMOD_ELF_32) { | |
958 | struct kmod_modversion32 *mv; | |
959 | verlen = sizeof(*mv); | |
960 | crclen = sizeof(mv->crc); | |
961 | } else { | |
962 | struct kmod_modversion64 *mv; | |
963 | verlen = sizeof(*mv); | |
964 | crclen = sizeof(mv->crc); | |
965 | } | |
966 | if (versionslen % verlen != 0) { | |
967 | ELFDBG(elf, "unexpected __versions of length %"PRIu64", not multiple of %zd as expected.\n", versionslen, verlen); | |
968 | versions = NULL; | |
969 | versionslen = 0; | |
970 | } | |
971 | } | |
972 | ||
973 | err = kmod_elf_get_section(elf, ".strtab", &strtab, &strtablen); | |
974 | if (err < 0) { | |
975 | ELFDBG(elf, "no .strtab found.\n"); | |
976 | return -EINVAL; | |
977 | } | |
978 | ||
979 | err = kmod_elf_get_section(elf, ".symtab", &symtab, &symtablen); | |
980 | if (err < 0) { | |
981 | ELFDBG(elf, "no .symtab found.\n"); | |
982 | return -EINVAL; | |
983 | } | |
984 | ||
985 | if (elf->class & KMOD_ELF_32) | |
986 | symlen = sizeof(Elf32_Sym); | |
987 | else | |
988 | symlen = sizeof(Elf64_Sym); | |
989 | ||
990 | if (symtablen % symlen != 0) { | |
991 | ELFDBG(elf, "unexpected .symtab of length %"PRIu64", not multiple of %"PRIu64" as expected.\n", symtablen, symlen); | |
992 | return -EINVAL; | |
993 | } | |
994 | ||
995 | if (versionslen == 0) { | |
996 | vercount = 0; | |
997 | visited_versions = NULL; | |
998 | } else { | |
999 | vercount = versionslen / verlen; | |
1000 | visited_versions = calloc(vercount, sizeof(uint8_t)); | |
1001 | if (visited_versions == NULL) | |
1002 | return -ENOMEM; | |
1003 | } | |
1004 | ||
1005 | handle_register_symbols = (elf->header.machine == EM_SPARC || | |
1006 | elf->header.machine == EM_SPARCV9); | |
1007 | ||
1008 | symcount = symtablen / symlen; | |
1009 | count = 0; | |
1010 | slen = 0; | |
1011 | str_off = (const uint8_t *)strtab - elf->memory; | |
1012 | sym_off = (const uint8_t *)symtab - elf->memory + symlen; | |
1013 | ||
1014 | symcrcs = calloc(symcount, sizeof(uint64_t)); | |
1015 | if (symcrcs == NULL) { | |
1016 | free(visited_versions); | |
1017 | return -ENOMEM; | |
1018 | } | |
1019 | ||
1020 | for (i = 1; i < symcount; i++, sym_off += symlen) { | |
1021 | const char *name; | |
1022 | uint64_t crc; | |
1023 | uint32_t name_off; | |
1024 | uint16_t secidx; | |
1025 | uint8_t info; | |
1026 | int idx; | |
1027 | ||
1028 | #define READV(field) \ | |
1029 | elf_get_uint(elf, sym_off + offsetof(typeof(*s), field),\ | |
1030 | sizeof(s->field)) | |
1031 | if (elf->class & KMOD_ELF_32) { | |
1032 | Elf32_Sym *s; | |
1033 | name_off = READV(st_name); | |
1034 | secidx = READV(st_shndx); | |
1035 | info = READV(st_info); | |
1036 | } else { | |
1037 | Elf64_Sym *s; | |
1038 | name_off = READV(st_name); | |
1039 | secidx = READV(st_shndx); | |
1040 | info = READV(st_info); | |
1041 | } | |
1042 | #undef READV | |
1043 | if (secidx != SHN_UNDEF) | |
1044 | continue; | |
1045 | ||
1046 | if (handle_register_symbols) { | |
1047 | uint8_t type; | |
1048 | if (elf->class & KMOD_ELF_32) | |
1049 | type = ELF32_ST_TYPE(info); | |
1050 | else | |
1051 | type = ELF64_ST_TYPE(info); | |
1052 | ||
1053 | /* Not really undefined: sparc gcc 3.3 creates | |
1054 | * U references when you have global asm | |
1055 | * variables, to avoid anyone else misusing | |
1056 | * them. | |
1057 | */ | |
1058 | if (type == STT_REGISTER) | |
1059 | continue; | |
1060 | } | |
1061 | ||
1062 | if (name_off >= strtablen) { | |
1063 | ELFDBG(elf, ".strtab is %"PRIu64" bytes, but .symtab entry %d wants to access offset %"PRIu32".\n", strtablen, i, name_off); | |
1064 | free(visited_versions); | |
1065 | free(symcrcs); | |
1066 | return -EINVAL; | |
1067 | } | |
1068 | ||
1069 | name = elf_get_mem(elf, str_off + name_off); | |
1070 | if (name[0] == '\0') { | |
1071 | ELFDBG(elf, "empty symbol name at index %"PRIu64"\n", i); | |
1072 | continue; | |
1073 | } | |
1074 | ||
1075 | slen += strlen(name) + 1; | |
1076 | count++; | |
1077 | ||
1078 | idx = kmod_elf_crc_find(elf, versions, versionslen, name, &crc); | |
1079 | if (idx >= 0 && visited_versions != NULL) | |
1080 | visited_versions[idx] = 1; | |
1081 | symcrcs[i] = crc; | |
1082 | } | |
1083 | ||
1084 | if (visited_versions != NULL) { | |
1085 | /* module_layout/struct_module are not visited, but needed */ | |
1086 | ver_off = (const uint8_t *)versions - elf->memory; | |
1087 | for (i = 0; i < vercount; i++) { | |
1088 | if (visited_versions[i] == 0) { | |
1089 | const char *name; | |
1090 | name = elf_get_mem(elf, ver_off + i * verlen + crclen); | |
1091 | slen += strlen(name) + 1; | |
1092 | ||
1093 | count++; | |
1094 | } | |
1095 | } | |
1096 | } | |
1097 | ||
1098 | if (count == 0) { | |
1099 | free(visited_versions); | |
1100 | free(symcrcs); | |
599a0324 | 1101 | *array = NULL; |
674f8590 GSB |
1102 | return 0; |
1103 | } | |
1104 | ||
1105 | *array = a = malloc(sizeof(struct kmod_modversion) * count + slen); | |
1106 | if (*array == NULL) { | |
1107 | free(visited_versions); | |
1108 | free(symcrcs); | |
1109 | return -errno; | |
1110 | } | |
1111 | ||
1112 | itr = (char *)(a + count); | |
1113 | count = 0; | |
1114 | str_off = (const uint8_t *)strtab - elf->memory; | |
1115 | sym_off = (const uint8_t *)symtab - elf->memory + symlen; | |
1116 | for (i = 1; i < symcount; i++, sym_off += symlen) { | |
1117 | const char *name; | |
1118 | uint64_t crc; | |
1119 | uint32_t name_off; | |
1120 | uint16_t secidx; | |
1121 | uint8_t info, bind; | |
1122 | ||
1123 | #define READV(field) \ | |
1124 | elf_get_uint(elf, sym_off + offsetof(typeof(*s), field),\ | |
1125 | sizeof(s->field)) | |
1126 | if (elf->class & KMOD_ELF_32) { | |
1127 | Elf32_Sym *s; | |
1128 | name_off = READV(st_name); | |
1129 | secidx = READV(st_shndx); | |
1130 | info = READV(st_info); | |
1131 | } else { | |
1132 | Elf64_Sym *s; | |
1133 | name_off = READV(st_name); | |
1134 | secidx = READV(st_shndx); | |
1135 | info = READV(st_info); | |
1136 | } | |
1137 | #undef READV | |
1138 | if (secidx != SHN_UNDEF) | |
1139 | continue; | |
1140 | ||
1141 | if (handle_register_symbols) { | |
1142 | uint8_t type; | |
1143 | if (elf->class & KMOD_ELF_32) | |
1144 | type = ELF32_ST_TYPE(info); | |
1145 | else | |
1146 | type = ELF64_ST_TYPE(info); | |
1147 | ||
1148 | /* Not really undefined: sparc gcc 3.3 creates | |
1149 | * U references when you have global asm | |
1150 | * variables, to avoid anyone else misusing | |
1151 | * them. | |
1152 | */ | |
1153 | if (type == STT_REGISTER) | |
1154 | continue; | |
1155 | } | |
1156 | ||
1157 | name = elf_get_mem(elf, str_off + name_off); | |
1158 | if (name[0] == '\0') { | |
1159 | ELFDBG(elf, "empty symbol name at index %"PRIu64"\n", i); | |
1160 | continue; | |
1161 | } | |
1162 | ||
1163 | if (elf->class & KMOD_ELF_32) | |
1164 | bind = ELF32_ST_BIND(info); | |
1165 | else | |
1166 | bind = ELF64_ST_BIND(info); | |
1167 | if (bind == STB_WEAK) | |
1168 | bind = KMOD_SYMBOL_WEAK; | |
1169 | else | |
1170 | bind = KMOD_SYMBOL_UNDEF; | |
1171 | ||
1172 | slen = strlen(name); | |
1173 | crc = symcrcs[i]; | |
1174 | ||
1175 | a[count].crc = crc; | |
1176 | a[count].bind = bind; | |
1177 | a[count].symbol = itr; | |
1178 | memcpy(itr, name, slen); | |
1179 | itr[slen] = '\0'; | |
1180 | itr += slen + 1; | |
1181 | ||
1182 | count++; | |
1183 | } | |
1184 | ||
1185 | free(symcrcs); | |
1186 | ||
1187 | if (visited_versions == NULL) | |
1188 | return count; | |
1189 | ||
1190 | /* add unvisited (module_layout/struct_module) */ | |
1191 | ver_off = (const uint8_t *)versions - elf->memory; | |
1192 | for (i = 0; i < vercount; i++) { | |
1193 | const char *name; | |
1194 | uint64_t crc; | |
1195 | ||
1196 | if (visited_versions[i] != 0) | |
1197 | continue; | |
1198 | ||
1199 | name = elf_get_mem(elf, ver_off + i * verlen + crclen); | |
1200 | slen = strlen(name); | |
1201 | crc = elf_get_uint(elf, ver_off + i * verlen, crclen); | |
1202 | ||
1203 | a[count].crc = crc; | |
1204 | a[count].bind = KMOD_SYMBOL_UNDEF; | |
1205 | a[count].symbol = itr; | |
1206 | memcpy(itr, name, slen); | |
1207 | itr[slen] = '\0'; | |
1208 | itr += slen + 1; | |
1209 | ||
1210 | count++; | |
1211 | } | |
1212 | free(visited_versions); | |
1213 | return count; | |
1214 | } |