?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
dm thin metadata: fix __udivdi3 undefined on 32-bit
[linux/fpc-iii.git] / scripts / mod / modpost.c
blob064fbfbbb22ca66cebfaa035eae62133122a50f9
1 /* Postprocess module symbol versions
2 *
3 * Copyright 2003 Kai Germaschewski
4 * Copyright 2002-2004 Rusty Russell, IBM Corporation
5 * Copyright 2006-2008 Sam Ravnborg
6 * Based in part on module-init-tools/depmod.c,file2alias
7 *
8 * This software may be used and distributed according to the terms
9 * of the GNU General Public License, incorporated herein by reference.
10 *
11 * Usage: modpost vmlinux module1.o module2.o ...
12 */
13
14 #define _GNU_SOURCE
15 #include <stdio.h>
16 #include <ctype.h>
17 #include <string.h>
18 #include <limits.h>
19 #include <stdbool.h>
20 #include <errno.h>
21 #include "modpost.h"
22 #include "../../include/generated/autoconf.h"
23 #include "../../include/linux/license.h"
24 #include "../../include/linux/export.h"
25
26 /* Are we using CONFIG_MODVERSIONS? */
27 static int modversions = 0;
28 /* Warn about undefined symbols? (do so if we have vmlinux) */
29 static int have_vmlinux = 0;
30 /* Is CONFIG_MODULE_SRCVERSION_ALL set? */
31 static int all_versions = 0;
32 /* If we are modposting external module set to 1 */
33 static int external_module = 0;
34 /* Warn about section mismatch in vmlinux if set to 1 */
35 static int vmlinux_section_warnings = 1;
36 /* Only warn about unresolved symbols */
37 static int warn_unresolved = 0;
38 /* How a symbol is exported */
39 static int sec_mismatch_count = 0;
40 static int sec_mismatch_verbose = 1;
41 static int sec_mismatch_fatal = 0;
42 /* ignore missing files */
43 static int ignore_missing_files;
44
45 enum export {
46 export_plain, export_unused, export_gpl,
47 export_unused_gpl, export_gpl_future, export_unknown
48 };
49
50 #define PRINTF __attribute__ ((format (printf, 1, 2)))
51
52 PRINTF void fatal(const char *fmt, ...)
53 {
54 va_list arglist;
55
56 fprintf(stderr, "FATAL: ");
57
58 va_start(arglist, fmt);
59 vfprintf(stderr, fmt, arglist);
60 va_end(arglist);
61
62 exit(1);
63 }
64
65 PRINTF void warn(const char *fmt, ...)
66 {
67 va_list arglist;
68
69 fprintf(stderr, "WARNING: ");
70
71 va_start(arglist, fmt);
72 vfprintf(stderr, fmt, arglist);
73 va_end(arglist);
74 }
75
76 PRINTF void merror(const char *fmt, ...)
77 {
78 va_list arglist;
79
80 fprintf(stderr, "ERROR: ");
81
82 va_start(arglist, fmt);
83 vfprintf(stderr, fmt, arglist);
84 va_end(arglist);
85 }
86
87 static inline bool strends(const char *str, const char *postfix)
88 {
89 if (strlen(str) < strlen(postfix))
90 return false;
91
92 return strcmp(str + strlen(str) - strlen(postfix), postfix) == 0;
93 }
94
95 static int is_vmlinux(const char *modname)
96 {
97 const char *myname;
98
99 myname = strrchr(modname, '/');
100 if (myname)
101 myname++;
102 else
103 myname = modname;
104
105 return (strcmp(myname, "vmlinux") == 0) ||
106 (strcmp(myname, "vmlinux.o") == 0);
107 }
108
109 void *do_nofail(void *ptr, const char *expr)
110 {
111 if (!ptr)
112 fatal("modpost: Memory allocation failure: %s.\n", expr);
113
114 return ptr;
115 }
116
117 /* A list of all modules we processed */
118 static struct module *modules;
119
120 static struct module *find_module(char *modname)
121 {
122 struct module *mod;
123
124 for (mod = modules; mod; mod = mod->next)
125 if (strcmp(mod->name, modname) == 0)
126 break;
127 return mod;
128 }
129
130 static struct module *new_module(const char *modname)
131 {
132 struct module *mod;
133 char *p;
134
135 mod = NOFAIL(malloc(sizeof(*mod)));
136 memset(mod, 0, sizeof(*mod));
137 p = NOFAIL(strdup(modname));
138
139 /* strip trailing .o */
140 if (strends(p, ".o")) {
141 p[strlen(p) - 2] = '\0';
142 mod->is_dot_o = 1;
143 }
144
145 /* add to list */
146 mod->name = p;
147 mod->gpl_compatible = -1;
148 mod->next = modules;
149 modules = mod;
150
151 return mod;
152 }
153
154 /* A hash of all exported symbols,
155 * struct symbol is also used for lists of unresolved symbols */
156
157 #define SYMBOL_HASH_SIZE 1024
158
159 struct symbol {
160 struct symbol *next;
161 struct module *module;
162 unsigned int crc;
163 int crc_valid;
164 unsigned int weak:1;
165 unsigned int vmlinux:1; /* 1 if symbol is defined in vmlinux */
166 unsigned int kernel:1; /* 1 if symbol is from kernel
167 * (only for external modules) **/
168 unsigned int preloaded:1; /* 1 if symbol from Module.symvers, or crc */
169 enum export export; /* Type of export */
170 char name[0];
171 };
172
173 static struct symbol *symbolhash[SYMBOL_HASH_SIZE];
174
175 /* This is based on the hash agorithm from gdbm, via tdb */
176 static inline unsigned int tdb_hash(const char *name)
177 {
178 unsigned value; /* Used to compute the hash value. */
179 unsigned i; /* Used to cycle through random values. */
180
181 /* Set the initial value from the key size. */
182 for (value = 0x238F13AF * strlen(name), i = 0; name[i]; i++)
183 value = (value + (((unsigned char *)name)[i] << (i*5 % 24)));
184
185 return (1103515243 * value + 12345);
186 }
187
188 /**
189 * Allocate a new symbols for use in the hash of exported symbols or
190 * the list of unresolved symbols per module
191 **/
192 static struct symbol *alloc_symbol(const char *name, unsigned int weak,
193 struct symbol *next)
194 {
195 struct symbol *s = NOFAIL(malloc(sizeof(*s) + strlen(name) + 1));
196
197 memset(s, 0, sizeof(*s));
198 strcpy(s->name, name);
199 s->weak = weak;
200 s->next = next;
201 return s;
202 }
203
204 /* For the hash of exported symbols */
205 static struct symbol *new_symbol(const char *name, struct module *module,
206 enum export export)
207 {
208 unsigned int hash;
209 struct symbol *new;
210
211 hash = tdb_hash(name) % SYMBOL_HASH_SIZE;
212 new = symbolhash[hash] = alloc_symbol(name, 0, symbolhash[hash]);
213 new->module = module;
214 new->export = export;
215 return new;
216 }
217
218 static struct symbol *find_symbol(const char *name)
219 {
220 struct symbol *s;
221
222 /* For our purposes, .foo matches foo. PPC64 needs this. */
223 if (name[0] == '.')
224 name++;
225
226 for (s = symbolhash[tdb_hash(name) % SYMBOL_HASH_SIZE]; s; s = s->next) {
227 if (strcmp(s->name, name) == 0)
228 return s;
229 }
230 return NULL;
231 }
232
233 static const struct {
234 const char *str;
235 enum export export;
236 } export_list[] = {
237 { .str = "EXPORT_SYMBOL", .export = export_plain },
238 { .str = "EXPORT_UNUSED_SYMBOL", .export = export_unused },
239 { .str = "EXPORT_SYMBOL_GPL", .export = export_gpl },
240 { .str = "EXPORT_UNUSED_SYMBOL_GPL", .export = export_unused_gpl },
241 { .str = "EXPORT_SYMBOL_GPL_FUTURE", .export = export_gpl_future },
242 { .str = "(unknown)", .export = export_unknown },
243 };
244
245
246 static const char *export_str(enum export ex)
247 {
248 return export_list[ex].str;
249 }
250
251 static enum export export_no(const char *s)
252 {
253 int i;
254
255 if (!s)
256 return export_unknown;
257 for (i = 0; export_list[i].export != export_unknown; i++) {
258 if (strcmp(export_list[i].str, s) == 0)
259 return export_list[i].export;
260 }
261 return export_unknown;
262 }
263
264 static const char *sec_name(struct elf_info *elf, int secindex);
265
266 #define strstarts(str, prefix) (strncmp(str, prefix, strlen(prefix)) == 0)
267
268 static enum export export_from_secname(struct elf_info *elf, unsigned int sec)
269 {
270 const char *secname = sec_name(elf, sec);
271
272 if (strstarts(secname, "___ksymtab+"))
273 return export_plain;
274 else if (strstarts(secname, "___ksymtab_unused+"))
275 return export_unused;
276 else if (strstarts(secname, "___ksymtab_gpl+"))
277 return export_gpl;
278 else if (strstarts(secname, "___ksymtab_unused_gpl+"))
279 return export_unused_gpl;
280 else if (strstarts(secname, "___ksymtab_gpl_future+"))
281 return export_gpl_future;
282 else
283 return export_unknown;
284 }
285
286 static enum export export_from_sec(struct elf_info *elf, unsigned int sec)
287 {
288 if (sec == elf->export_sec)
289 return export_plain;
290 else if (sec == elf->export_unused_sec)
291 return export_unused;
292 else if (sec == elf->export_gpl_sec)
293 return export_gpl;
294 else if (sec == elf->export_unused_gpl_sec)
295 return export_unused_gpl;
296 else if (sec == elf->export_gpl_future_sec)
297 return export_gpl_future;
298 else
299 return export_unknown;
300 }
301
302 /**
303 * Add an exported symbol - it may have already been added without a
304 * CRC, in this case just update the CRC
305 **/
306 static struct symbol *sym_add_exported(const char *name, struct module *mod,
307 enum export export)
308 {
309 struct symbol *s = find_symbol(name);
310
311 if (!s) {
312 s = new_symbol(name, mod, export);
313 } else {
314 if (!s->preloaded) {
315 warn("%s: '%s' exported twice. Previous export "
316 "was in %s%s\n", mod->name, name,
317 s->module->name,
318 is_vmlinux(s->module->name) ?"":".ko");
319 } else {
320 /* In case Module.symvers was out of date */
321 s->module = mod;
322 }
323 }
324 s->preloaded = 0;
325 s->vmlinux = is_vmlinux(mod->name);
326 s->kernel = 0;
327 s->export = export;
328 return s;
329 }
330
331 static void sym_update_crc(const char *name, struct module *mod,
332 unsigned int crc, enum export export)
333 {
334 struct symbol *s = find_symbol(name);
335
336 if (!s) {
337 s = new_symbol(name, mod, export);
338 /* Don't complain when we find it later. */
339 s->preloaded = 1;
340 }
341 s->crc = crc;
342 s->crc_valid = 1;
343 }
344
345 void *grab_file(const char *filename, unsigned long *size)
346 {
347 struct stat st;
348 void *map = MAP_FAILED;
349 int fd;
350
351 fd = open(filename, O_RDONLY);
352 if (fd < 0)
353 return NULL;
354 if (fstat(fd, &st))
355 goto failed;
356
357 *size = st.st_size;
358 map = mmap(NULL, *size, PROT_READ|PROT_WRITE, MAP_PRIVATE, fd, 0);
359
360 failed:
361 close(fd);
362 if (map == MAP_FAILED)
363 return NULL;
364 return map;
365 }
366
367 /**
368 * Return a copy of the next line in a mmap'ed file.
369 * spaces in the beginning of the line is trimmed away.
370 * Return a pointer to a static buffer.
371 **/
372 char *get_next_line(unsigned long *pos, void *file, unsigned long size)
373 {
374 static char line[4096];
375 int skip = 1;
376 size_t len = 0;
377 signed char *p = (signed char *)file + *pos;
378 char *s = line;
379
380 for (; *pos < size ; (*pos)++) {
381 if (skip && isspace(*p)) {
382 p++;
383 continue;
384 }
385 skip = 0;
386 if (*p != '\n' && (*pos < size)) {
387 len++;
388 *s++ = *p++;
389 if (len > 4095)
390 break; /* Too long, stop */
391 } else {
392 /* End of string */
393 *s = '\0';
394 return line;
395 }
396 }
397 /* End of buffer */
398 return NULL;
399 }
400
401 void release_file(void *file, unsigned long size)
402 {
403 munmap(file, size);
404 }
405
406 static int parse_elf(struct elf_info *info, const char *filename)
407 {
408 unsigned int i;
409 Elf_Ehdr *hdr;
410 Elf_Shdr *sechdrs;
411 Elf_Sym *sym;
412 const char *secstrings;
413 unsigned int symtab_idx = ~0U, symtab_shndx_idx = ~0U;
414
415 hdr = grab_file(filename, &info->size);
416 if (!hdr) {
417 if (ignore_missing_files) {
418 fprintf(stderr, "%s: %s (ignored)\n", filename,
419 strerror(errno));
420 return 0;
421 }
422 perror(filename);
423 exit(1);
424 }
425 info->hdr = hdr;
426 if (info->size < sizeof(*hdr)) {
427 /* file too small, assume this is an empty .o file */
428 return 0;
429 }
430 /* Is this a valid ELF file? */
431 if ((hdr->e_ident[EI_MAG0] != ELFMAG0) ||
432 (hdr->e_ident[EI_MAG1] != ELFMAG1) ||
433 (hdr->e_ident[EI_MAG2] != ELFMAG2) ||
434 (hdr->e_ident[EI_MAG3] != ELFMAG3)) {
435 /* Not an ELF file - silently ignore it */
436 return 0;
437 }
438 /* Fix endianness in ELF header */
439 hdr->e_type = TO_NATIVE(hdr->e_type);
440 hdr->e_machine = TO_NATIVE(hdr->e_machine);
441 hdr->e_version = TO_NATIVE(hdr->e_version);
442 hdr->e_entry = TO_NATIVE(hdr->e_entry);
443 hdr->e_phoff = TO_NATIVE(hdr->e_phoff);
444 hdr->e_shoff = TO_NATIVE(hdr->e_shoff);
445 hdr->e_flags = TO_NATIVE(hdr->e_flags);
446 hdr->e_ehsize = TO_NATIVE(hdr->e_ehsize);
447 hdr->e_phentsize = TO_NATIVE(hdr->e_phentsize);
448 hdr->e_phnum = TO_NATIVE(hdr->e_phnum);
449 hdr->e_shentsize = TO_NATIVE(hdr->e_shentsize);
450 hdr->e_shnum = TO_NATIVE(hdr->e_shnum);
451 hdr->e_shstrndx = TO_NATIVE(hdr->e_shstrndx);
452 sechdrs = (void *)hdr + hdr->e_shoff;
453 info->sechdrs = sechdrs;
454
455 /* Check if file offset is correct */
456 if (hdr->e_shoff > info->size) {
457 fatal("section header offset=%lu in file '%s' is bigger than "
458 "filesize=%lu\n", (unsigned long)hdr->e_shoff,
459 filename, info->size);
460 return 0;
461 }
462
463 if (hdr->e_shnum == SHN_UNDEF) {
464 /*
465 * There are more than 64k sections,
466 * read count from .sh_size.
467 */
468 info->num_sections = TO_NATIVE(sechdrs[0].sh_size);
469 }
470 else {
471 info->num_sections = hdr->e_shnum;
472 }
473 if (hdr->e_shstrndx == SHN_XINDEX) {
474 info->secindex_strings = TO_NATIVE(sechdrs[0].sh_link);
475 }
476 else {
477 info->secindex_strings = hdr->e_shstrndx;
478 }
479
480 /* Fix endianness in section headers */
481 for (i = 0; i < info->num_sections; i++) {
482 sechdrs[i].sh_name = TO_NATIVE(sechdrs[i].sh_name);
483 sechdrs[i].sh_type = TO_NATIVE(sechdrs[i].sh_type);
484 sechdrs[i].sh_flags = TO_NATIVE(sechdrs[i].sh_flags);
485 sechdrs[i].sh_addr = TO_NATIVE(sechdrs[i].sh_addr);
486 sechdrs[i].sh_offset = TO_NATIVE(sechdrs[i].sh_offset);
487 sechdrs[i].sh_size = TO_NATIVE(sechdrs[i].sh_size);
488 sechdrs[i].sh_link = TO_NATIVE(sechdrs[i].sh_link);
489 sechdrs[i].sh_info = TO_NATIVE(sechdrs[i].sh_info);
490 sechdrs[i].sh_addralign = TO_NATIVE(sechdrs[i].sh_addralign);
491 sechdrs[i].sh_entsize = TO_NATIVE(sechdrs[i].sh_entsize);
492 }
493 /* Find symbol table. */
494 secstrings = (void *)hdr + sechdrs[info->secindex_strings].sh_offset;
495 for (i = 1; i < info->num_sections; i++) {
496 const char *secname;
497 int nobits = sechdrs[i].sh_type == SHT_NOBITS;
498
499 if (!nobits && sechdrs[i].sh_offset > info->size) {
500 fatal("%s is truncated. sechdrs[i].sh_offset=%lu > "
501 "sizeof(*hrd)=%zu\n", filename,
502 (unsigned long)sechdrs[i].sh_offset,
503 sizeof(*hdr));
504 return 0;
505 }
506 secname = secstrings + sechdrs[i].sh_name;
507 if (strcmp(secname, ".modinfo") == 0) {
508 if (nobits)
509 fatal("%s has NOBITS .modinfo\n", filename);
510 info->modinfo = (void *)hdr + sechdrs[i].sh_offset;
511 info->modinfo_len = sechdrs[i].sh_size;
512 } else if (strcmp(secname, "__ksymtab") == 0)
513 info->export_sec = i;
514 else if (strcmp(secname, "__ksymtab_unused") == 0)
515 info->export_unused_sec = i;
516 else if (strcmp(secname, "__ksymtab_gpl") == 0)
517 info->export_gpl_sec = i;
518 else if (strcmp(secname, "__ksymtab_unused_gpl") == 0)
519 info->export_unused_gpl_sec = i;
520 else if (strcmp(secname, "__ksymtab_gpl_future") == 0)
521 info->export_gpl_future_sec = i;
522
523 if (sechdrs[i].sh_type == SHT_SYMTAB) {
524 unsigned int sh_link_idx;
525 symtab_idx = i;
526 info->symtab_start = (void *)hdr +
527 sechdrs[i].sh_offset;
528 info->symtab_stop = (void *)hdr +
529 sechdrs[i].sh_offset + sechdrs[i].sh_size;
530 sh_link_idx = sechdrs[i].sh_link;
531 info->strtab = (void *)hdr +
532 sechdrs[sh_link_idx].sh_offset;
533 }
534
535 /* 32bit section no. table? ("more than 64k sections") */
536 if (sechdrs[i].sh_type == SHT_SYMTAB_SHNDX) {
537 symtab_shndx_idx = i;
538 info->symtab_shndx_start = (void *)hdr +
539 sechdrs[i].sh_offset;
540 info->symtab_shndx_stop = (void *)hdr +
541 sechdrs[i].sh_offset + sechdrs[i].sh_size;
542 }
543 }
544 if (!info->symtab_start)
545 fatal("%s has no symtab?\n", filename);
546
547 /* Fix endianness in symbols */
548 for (sym = info->symtab_start; sym < info->symtab_stop; sym++) {
549 sym->st_shndx = TO_NATIVE(sym->st_shndx);
550 sym->st_name = TO_NATIVE(sym->st_name);
551 sym->st_value = TO_NATIVE(sym->st_value);
552 sym->st_size = TO_NATIVE(sym->st_size);
553 }
554
555 if (symtab_shndx_idx != ~0U) {
556 Elf32_Word *p;
557 if (symtab_idx != sechdrs[symtab_shndx_idx].sh_link)
558 fatal("%s: SYMTAB_SHNDX has bad sh_link: %u!=%u\n",
559 filename, sechdrs[symtab_shndx_idx].sh_link,
560 symtab_idx);
561 /* Fix endianness */
562 for (p = info->symtab_shndx_start; p < info->symtab_shndx_stop;
563 p++)
564 *p = TO_NATIVE(*p);
565 }
566
567 return 1;
568 }
569
570 static void parse_elf_finish(struct elf_info *info)
571 {
572 release_file(info->hdr, info->size);
573 }
574
575 static int ignore_undef_symbol(struct elf_info *info, const char *symname)
576 {
577 /* ignore __this_module, it will be resolved shortly */
578 if (strcmp(symname, VMLINUX_SYMBOL_STR(__this_module)) == 0)
579 return 1;
580 /* ignore global offset table */
581 if (strcmp(symname, "_GLOBAL_OFFSET_TABLE_") == 0)
582 return 1;
583 if (info->hdr->e_machine == EM_PPC)
584 /* Special register function linked on all modules during final link of .ko */
585 if (strncmp(symname, "_restgpr_", sizeof("_restgpr_") - 1) == 0 ||
586 strncmp(symname, "_savegpr_", sizeof("_savegpr_") - 1) == 0 ||
587 strncmp(symname, "_rest32gpr_", sizeof("_rest32gpr_") - 1) == 0 ||
588 strncmp(symname, "_save32gpr_", sizeof("_save32gpr_") - 1) == 0 ||
589 strncmp(symname, "_restvr_", sizeof("_restvr_") - 1) == 0 ||
590 strncmp(symname, "_savevr_", sizeof("_savevr_") - 1) == 0)
591 return 1;
592 if (info->hdr->e_machine == EM_PPC64)
593 /* Special register function linked on all modules during final link of .ko */
594 if (strncmp(symname, "_restgpr0_", sizeof("_restgpr0_") - 1) == 0 ||
595 strncmp(symname, "_savegpr0_", sizeof("_savegpr0_") - 1) == 0 ||
596 strncmp(symname, "_restvr_", sizeof("_restvr_") - 1) == 0 ||
597 strncmp(symname, "_savevr_", sizeof("_savevr_") - 1) == 0 ||
598 strcmp(symname, ".TOC.") == 0)
599 return 1;
600 /* Do not ignore this symbol */
601 return 0;
602 }
603
604 #define CRC_PFX VMLINUX_SYMBOL_STR(__crc_)
605 #define KSYMTAB_PFX VMLINUX_SYMBOL_STR(__ksymtab_)
606
607 static void handle_modversions(struct module *mod, struct elf_info *info,
608 Elf_Sym *sym, const char *symname)
609 {
610 unsigned int crc;
611 enum export export;
612
613 if ((!is_vmlinux(mod->name) || mod->is_dot_o) &&
614 strncmp(symname, "__ksymtab", 9) == 0)
615 export = export_from_secname(info, get_secindex(info, sym));
616 else
617 export = export_from_sec(info, get_secindex(info, sym));
618
619 /* CRC'd symbol */
620 if (strncmp(symname, CRC_PFX, strlen(CRC_PFX)) == 0) {
621 crc = (unsigned int) sym->st_value;
622 sym_update_crc(symname + strlen(CRC_PFX), mod, crc,
623 export);
624 }
625
626 switch (sym->st_shndx) {
627 case SHN_COMMON:
628 if (!strncmp(symname, "__gnu_lto_", sizeof("__gnu_lto_")-1)) {
629 /* Should warn here, but modpost runs before the linker */
630 } else
631 warn("\"%s\" [%s] is COMMON symbol\n", symname, mod->name);
632 break;
633 case SHN_UNDEF:
634 /* undefined symbol */
635 if (ELF_ST_BIND(sym->st_info) != STB_GLOBAL &&
636 ELF_ST_BIND(sym->st_info) != STB_WEAK)
637 break;
638 if (ignore_undef_symbol(info, symname))
639 break;
640 /* cope with newer glibc (2.3.4 or higher) STT_ definition in elf.h */
641 #if defined(STT_REGISTER) || defined(STT_SPARC_REGISTER)
642 /* add compatibility with older glibc */
643 #ifndef STT_SPARC_REGISTER
644 #define STT_SPARC_REGISTER STT_REGISTER
645 #endif
646 if (info->hdr->e_machine == EM_SPARC ||
647 info->hdr->e_machine == EM_SPARCV9) {
648 /* Ignore register directives. */
649 if (ELF_ST_TYPE(sym->st_info) == STT_SPARC_REGISTER)
650 break;
651 if (symname[0] == '.') {
652 char *munged = NOFAIL(strdup(symname));
653 munged[0] = '_';
654 munged[1] = toupper(munged[1]);
655 symname = munged;
656 }
657 }
658 #endif
659
660 #ifdef CONFIG_HAVE_UNDERSCORE_SYMBOL_PREFIX
661 if (symname[0] != '_')
662 break;
663 else
664 symname++;
665 #endif
666 mod->unres = alloc_symbol(symname,
667 ELF_ST_BIND(sym->st_info) == STB_WEAK,
668 mod->unres);
669 break;
670 default:
671 /* All exported symbols */
672 if (strncmp(symname, KSYMTAB_PFX, strlen(KSYMTAB_PFX)) == 0) {
673 sym_add_exported(symname + strlen(KSYMTAB_PFX), mod,
674 export);
675 }
676 if (strcmp(symname, VMLINUX_SYMBOL_STR(init_module)) == 0)
677 mod->has_init = 1;
678 if (strcmp(symname, VMLINUX_SYMBOL_STR(cleanup_module)) == 0)
679 mod->has_cleanup = 1;
680 break;
681 }
682 }
683
684 /**
685 * Parse tag=value strings from .modinfo section
686 **/
687 static char *next_string(char *string, unsigned long *secsize)
688 {
689 /* Skip non-zero chars */
690 while (string[0]) {
691 string++;
692 if ((*secsize)-- <= 1)
693 return NULL;
694 }
695
696 /* Skip any zero padding. */
697 while (!string[0]) {
698 string++;
699 if ((*secsize)-- <= 1)
700 return NULL;
701 }
702 return string;
703 }
704
705 static char *get_next_modinfo(void *modinfo, unsigned long modinfo_len,
706 const char *tag, char *info)
707 {
708 char *p;
709 unsigned int taglen = strlen(tag);
710 unsigned long size = modinfo_len;
711
712 if (info) {
713 size -= info - (char *)modinfo;
714 modinfo = next_string(info, &size);
715 }
716
717 for (p = modinfo; p; p = next_string(p, &size)) {
718 if (strncmp(p, tag, taglen) == 0 && p[taglen] == '=')
719 return p + taglen + 1;
720 }
721 return NULL;
722 }
723
724 static char *get_modinfo(void *modinfo, unsigned long modinfo_len,
725 const char *tag)
726
727 {
728 return get_next_modinfo(modinfo, modinfo_len, tag, NULL);
729 }
730
731 /**
732 * Test if string s ends in string sub
733 * return 0 if match
734 **/
735 static int strrcmp(const char *s, const char *sub)
736 {
737 int slen, sublen;
738
739 if (!s || !sub)
740 return 1;
741
742 slen = strlen(s);
743 sublen = strlen(sub);
744
745 if ((slen == 0) || (sublen == 0))
746 return 1;
747
748 if (sublen > slen)
749 return 1;
750
751 return memcmp(s + slen - sublen, sub, sublen);
752 }
753
754 static const char *sym_name(struct elf_info *elf, Elf_Sym *sym)
755 {
756 if (sym)
757 return elf->strtab + sym->st_name;
758 else
759 return "(unknown)";
760 }
761
762 static const char *sec_name(struct elf_info *elf, int secindex)
763 {
764 Elf_Shdr *sechdrs = elf->sechdrs;
765 return (void *)elf->hdr +
766 elf->sechdrs[elf->secindex_strings].sh_offset +
767 sechdrs[secindex].sh_name;
768 }
769
770 static const char *sech_name(struct elf_info *elf, Elf_Shdr *sechdr)
771 {
772 return (void *)elf->hdr +
773 elf->sechdrs[elf->secindex_strings].sh_offset +
774 sechdr->sh_name;
775 }
776
777 /* The pattern is an array of simple patterns.
778 * "foo" will match an exact string equal to "foo"
779 * "*foo" will match a string that ends with "foo"
780 * "foo*" will match a string that begins with "foo"
781 * "*foo*" will match a string that contains "foo"
782 */
783 static int match(const char *sym, const char * const pat[])
784 {
785 const char *p;
786 while (*pat) {
787 p = *pat++;
788 const char *endp = p + strlen(p) - 1;
789
790 /* "*foo*" */
791 if (*p == '*' && *endp == '*') {
792 char *here, *bare = strndup(p + 1, strlen(p) - 2);
793
794 here = strstr(sym, bare);
795 free(bare);
796 if (here != NULL)
797 return 1;
798 }
799 /* "*foo" */
800 else if (*p == '*') {
801 if (strrcmp(sym, p + 1) == 0)
802 return 1;
803 }
804 /* "foo*" */
805 else if (*endp == '*') {
806 if (strncmp(sym, p, strlen(p) - 1) == 0)
807 return 1;
808 }
809 /* no wildcards */
810 else {
811 if (strcmp(p, sym) == 0)
812 return 1;
813 }
814 }
815 /* no match */
816 return 0;
817 }
818
819 /* sections that we do not want to do full section mismatch check on */
820 static const char *const section_white_list[] =
821 {
822 ".comment*",
823 ".debug*",
824 ".cranges", /* sh64 */
825 ".zdebug*", /* Compressed debug sections. */
826 ".GCC-command-line", /* mn10300 */
827 ".GCC.command.line", /* record-gcc-switches, non mn10300 */
828 ".mdebug*", /* alpha, score, mips etc. */
829 ".pdr", /* alpha, score, mips etc. */
830 ".stab*",
831 ".note*",
832 ".got*",
833 ".toc*",
834 ".xt.prop", /* xtensa */
835 ".xt.lit", /* xtensa */
836 ".arcextmap*", /* arc */
837 ".gnu.linkonce.arcext*", /* arc : modules */
838 ".cmem*", /* EZchip */
839 ".fmt_slot*", /* EZchip */
840 ".gnu.lto*",
841 NULL
842 };
843
844 /*
845 * This is used to find sections missing the SHF_ALLOC flag.
846 * The cause of this is often a section specified in assembler
847 * without "ax" / "aw".
848 */
849 static void check_section(const char *modname, struct elf_info *elf,
850 Elf_Shdr *sechdr)
851 {
852 const char *sec = sech_name(elf, sechdr);
853
854 if (sechdr->sh_type == SHT_PROGBITS &&
855 !(sechdr->sh_flags & SHF_ALLOC) &&
856 !match(sec, section_white_list)) {
857 warn("%s (%s): unexpected non-allocatable section.\n"
858 "Did you forget to use \"ax\"/\"aw\" in a .S file?\n"
859 "Note that for example <linux/init.h> contains\n"
860 "section definitions for use in .S files.\n\n",
861 modname, sec);
862 }
863 }
864
865
866
867 #define ALL_INIT_DATA_SECTIONS \
868 ".init.setup", ".init.rodata", ".meminit.rodata", \
869 ".init.data", ".meminit.data"
870 #define ALL_EXIT_DATA_SECTIONS \
871 ".exit.data", ".memexit.data"
872
873 #define ALL_INIT_TEXT_SECTIONS \
874 ".init.text", ".meminit.text"
875 #define ALL_EXIT_TEXT_SECTIONS \
876 ".exit.text", ".memexit.text"
877
878 #define ALL_PCI_INIT_SECTIONS \
879 ".pci_fixup_early", ".pci_fixup_header", ".pci_fixup_final", \
880 ".pci_fixup_enable", ".pci_fixup_resume", \
881 ".pci_fixup_resume_early", ".pci_fixup_suspend"
882
883 #define ALL_XXXINIT_SECTIONS MEM_INIT_SECTIONS
884 #define ALL_XXXEXIT_SECTIONS MEM_EXIT_SECTIONS
885
886 #define ALL_INIT_SECTIONS INIT_SECTIONS, ALL_XXXINIT_SECTIONS
887 #define ALL_EXIT_SECTIONS EXIT_SECTIONS, ALL_XXXEXIT_SECTIONS
888
889 #define DATA_SECTIONS ".data", ".data.rel"
890 #define TEXT_SECTIONS ".text", ".text.unlikely", ".sched.text", \
891 ".kprobes.text"
892 #define OTHER_TEXT_SECTIONS ".ref.text", ".head.text", ".spinlock.text", \
893 ".fixup", ".entry.text", ".exception.text", ".text.*", \
894 ".coldtext"
895
896 #define INIT_SECTIONS ".init.*"
897 #define MEM_INIT_SECTIONS ".meminit.*"
898
899 #define EXIT_SECTIONS ".exit.*"
900 #define MEM_EXIT_SECTIONS ".memexit.*"
901
902 #define ALL_TEXT_SECTIONS ALL_INIT_TEXT_SECTIONS, ALL_EXIT_TEXT_SECTIONS, \
903 TEXT_SECTIONS, OTHER_TEXT_SECTIONS
904
905 /* init data sections */
906 static const char *const init_data_sections[] =
907 { ALL_INIT_DATA_SECTIONS, NULL };
908
909 /* all init sections */
910 static const char *const init_sections[] = { ALL_INIT_SECTIONS, NULL };
911
912 /* All init and exit sections (code + data) */
913 static const char *const init_exit_sections[] =
914 {ALL_INIT_SECTIONS, ALL_EXIT_SECTIONS, NULL };
915
916 /* all text sections */
917 static const char *const text_sections[] = { ALL_TEXT_SECTIONS, NULL };
918
919 /* data section */
920 static const char *const data_sections[] = { DATA_SECTIONS, NULL };
921
922
923 /* symbols in .data that may refer to init/exit sections */
924 #define DEFAULT_SYMBOL_WHITE_LIST \
925 "*driver", \
926 "*_template", /* scsi uses *_template a lot */ \
927 "*_timer", /* arm uses ops structures named _timer a lot */ \
928 "*_sht", /* scsi also used *_sht to some extent */ \
929 "*_ops", \
930 "*_probe", \
931 "*_probe_one", \
932 "*_console"
933
934 static const char *const head_sections[] = { ".head.text*", NULL };
935 static const char *const linker_symbols[] =
936 { "__init_begin", "_sinittext", "_einittext", NULL };
937 static const char *const optim_symbols[] = { "*.constprop.*", NULL };
938
939 enum mismatch {
940 TEXT_TO_ANY_INIT,
941 DATA_TO_ANY_INIT,
942 TEXT_TO_ANY_EXIT,
943 DATA_TO_ANY_EXIT,
944 XXXINIT_TO_SOME_INIT,
945 XXXEXIT_TO_SOME_EXIT,
946 ANY_INIT_TO_ANY_EXIT,
947 ANY_EXIT_TO_ANY_INIT,
948 EXPORT_TO_INIT_EXIT,
949 EXTABLE_TO_NON_TEXT,
950 };
951
952 /**
953 * Describe how to match sections on different criterias:
954 *
955 * @fromsec: Array of sections to be matched.
956 *
957 * @bad_tosec: Relocations applied to a section in @fromsec to a section in
958 * this array is forbidden (black-list). Can be empty.
959 *
960 * @good_tosec: Relocations applied to a section in @fromsec must be
961 * targetting sections in this array (white-list). Can be empty.
962 *
963 * @mismatch: Type of mismatch.
964 *
965 * @symbol_white_list: Do not match a relocation to a symbol in this list
966 * even if it is targetting a section in @bad_to_sec.
967 *
968 * @handler: Specific handler to call when a match is found. If NULL,
969 * default_mismatch_handler() will be called.
970 *
971 */
972 struct sectioncheck {
973 const char *fromsec[20];
974 const char *bad_tosec[20];
975 const char *good_tosec[20];
976 enum mismatch mismatch;
977 const char *symbol_white_list[20];
978 void (*handler)(const char *modname, struct elf_info *elf,
979 const struct sectioncheck* const mismatch,
980 Elf_Rela *r, Elf_Sym *sym, const char *fromsec);
981
982 };
983
984 static void extable_mismatch_handler(const char *modname, struct elf_info *elf,
985 const struct sectioncheck* const mismatch,
986 Elf_Rela *r, Elf_Sym *sym,
987 const char *fromsec);
988
989 static const struct sectioncheck sectioncheck[] = {
990 /* Do not reference init/exit code/data from
991 * normal code and data
992 */
993 {
994 .fromsec = { TEXT_SECTIONS, NULL },
995 .bad_tosec = { ALL_INIT_SECTIONS, NULL },
996 .mismatch = TEXT_TO_ANY_INIT,
997 .symbol_white_list = { DEFAULT_SYMBOL_WHITE_LIST, NULL },
998 },
999 {
1000 .fromsec = { DATA_SECTIONS, NULL },
1001 .bad_tosec = { ALL_XXXINIT_SECTIONS, NULL },
1002 .mismatch = DATA_TO_ANY_INIT,
1003 .symbol_white_list = { DEFAULT_SYMBOL_WHITE_LIST, NULL },
1004 },
1005 {
1006 .fromsec = { DATA_SECTIONS, NULL },
1007 .bad_tosec = { INIT_SECTIONS, NULL },
1008 .mismatch = DATA_TO_ANY_INIT,
1009 .symbol_white_list = {
1010 "*_template", "*_timer", "*_sht", "*_ops",
1011 "*_probe", "*_probe_one", "*_console", NULL
1012 },
1013 },
1014 {
1015 .fromsec = { TEXT_SECTIONS, NULL },
1016 .bad_tosec = { ALL_EXIT_SECTIONS, NULL },
1017 .mismatch = TEXT_TO_ANY_EXIT,
1018 .symbol_white_list = { DEFAULT_SYMBOL_WHITE_LIST, NULL },
1019 },
1020 {
1021 .fromsec = { DATA_SECTIONS, NULL },
1022 .bad_tosec = { ALL_EXIT_SECTIONS, NULL },
1023 .mismatch = DATA_TO_ANY_EXIT,
1024 .symbol_white_list = { DEFAULT_SYMBOL_WHITE_LIST, NULL },
1025 },
1026 /* Do not reference init code/data from meminit code/data */
1027 {
1028 .fromsec = { ALL_XXXINIT_SECTIONS, NULL },
1029 .bad_tosec = { INIT_SECTIONS, NULL },
1030 .mismatch = XXXINIT_TO_SOME_INIT,
1031 .symbol_white_list = { DEFAULT_SYMBOL_WHITE_LIST, NULL },
1032 },
1033 /* Do not reference exit code/data from memexit code/data */
1034 {
1035 .fromsec = { ALL_XXXEXIT_SECTIONS, NULL },
1036 .bad_tosec = { EXIT_SECTIONS, NULL },
1037 .mismatch = XXXEXIT_TO_SOME_EXIT,
1038 .symbol_white_list = { DEFAULT_SYMBOL_WHITE_LIST, NULL },
1039 },
1040 /* Do not use exit code/data from init code */
1041 {
1042 .fromsec = { ALL_INIT_SECTIONS, NULL },
1043 .bad_tosec = { ALL_EXIT_SECTIONS, NULL },
1044 .mismatch = ANY_INIT_TO_ANY_EXIT,
1045 .symbol_white_list = { DEFAULT_SYMBOL_WHITE_LIST, NULL },
1046 },
1047 /* Do not use init code/data from exit code */
1048 {
1049 .fromsec = { ALL_EXIT_SECTIONS, NULL },
1050 .bad_tosec = { ALL_INIT_SECTIONS, NULL },
1051 .mismatch = ANY_EXIT_TO_ANY_INIT,
1052 .symbol_white_list = { DEFAULT_SYMBOL_WHITE_LIST, NULL },
1053 },
1054 {
1055 .fromsec = { ALL_PCI_INIT_SECTIONS, NULL },
1056 .bad_tosec = { INIT_SECTIONS, NULL },
1057 .mismatch = ANY_INIT_TO_ANY_EXIT,
1058 .symbol_white_list = { NULL },
1059 },
1060 /* Do not export init/exit functions or data */
1061 {
1062 .fromsec = { "__ksymtab*", NULL },
1063 .bad_tosec = { INIT_SECTIONS, EXIT_SECTIONS, NULL },
1064 .mismatch = EXPORT_TO_INIT_EXIT,
1065 .symbol_white_list = { DEFAULT_SYMBOL_WHITE_LIST, NULL },
1066 },
1067 {
1068 .fromsec = { "__ex_table", NULL },
1069 /* If you're adding any new black-listed sections in here, consider
1070 * adding a special 'printer' for them in scripts/check_extable.
1071 */
1072 .bad_tosec = { ".altinstr_replacement", NULL },
1073 .good_tosec = {ALL_TEXT_SECTIONS , NULL},
1074 .mismatch = EXTABLE_TO_NON_TEXT,
1075 .handler = extable_mismatch_handler,
1076 }
1077 };
1078
1079 static const struct sectioncheck *section_mismatch(
1080 const char *fromsec, const char *tosec)
1081 {
1082 int i;
1083 int elems = sizeof(sectioncheck) / sizeof(struct sectioncheck);
1084 const struct sectioncheck *check = &sectioncheck[0];
1085
1086 /*
1087 * The target section could be the SHT_NUL section when we're
1088 * handling relocations to un-resolved symbols, trying to match it
1089 * doesn't make much sense and causes build failures on parisc and
1090 * mn10300 architectures.
1091 */
1092 if (*tosec == '\0')
1093 return NULL;
1094
1095 for (i = 0; i < elems; i++) {
1096 if (match(fromsec, check->fromsec)) {
1097 if (check->bad_tosec[0] && match(tosec, check->bad_tosec))
1098 return check;
1099 if (check->good_tosec[0] && !match(tosec, check->good_tosec))
1100 return check;
1101 }
1102 check++;
1103 }
1104 return NULL;
1105 }
1106
1107 /**
1108 * Whitelist to allow certain references to pass with no warning.
1109 *
1110 * Pattern 1:
1111 * If a module parameter is declared __initdata and permissions=0
1112 * then this is legal despite the warning generated.
1113 * We cannot see value of permissions here, so just ignore
1114 * this pattern.
1115 * The pattern is identified by:
1116 * tosec = .init.data
1117 * fromsec = .data*
1118 * atsym =__param*
1119 *
1120 * Pattern 1a:
1121 * module_param_call() ops can refer to __init set function if permissions=0
1122 * The pattern is identified by:
1123 * tosec = .init.text
1124 * fromsec = .data*
1125 * atsym = __param_ops_*
1126 *
1127 * Pattern 2:
1128 * Many drivers utilise a *driver container with references to
1129 * add, remove, probe functions etc.
1130 * the pattern is identified by:
1131 * tosec = init or exit section
1132 * fromsec = data section
1133 * atsym = *driver, *_template, *_sht, *_ops, *_probe,
1134 * *probe_one, *_console, *_timer
1135 *
1136 * Pattern 3:
1137 * Whitelist all references from .head.text to any init section
1138 *
1139 * Pattern 4:
1140 * Some symbols belong to init section but still it is ok to reference
1141 * these from non-init sections as these symbols don't have any memory
1142 * allocated for them and symbol address and value are same. So even
1143 * if init section is freed, its ok to reference those symbols.
1144 * For ex. symbols marking the init section boundaries.
1145 * This pattern is identified by
1146 * refsymname = __init_begin, _sinittext, _einittext
1147 *
1148 * Pattern 5:
1149 * GCC may optimize static inlines when fed constant arg(s) resulting
1150 * in functions like cpumask_empty() -- generating an associated symbol
1151 * cpumask_empty.constprop.3 that appears in the audit. If the const that
1152 * is passed in comes from __init, like say nmi_ipi_mask, we get a
1153 * meaningless section warning. May need to add isra symbols too...
1154 * This pattern is identified by
1155 * tosec = init section
1156 * fromsec = text section
1157 * refsymname = *.constprop.*
1158 *
1159 **/
1160 static int secref_whitelist(const struct sectioncheck *mismatch,
1161 const char *fromsec, const char *fromsym,
1162 const char *tosec, const char *tosym)
1163 {
1164 /* Check for pattern 1 */
1165 if (match(tosec, init_data_sections) &&
1166 match(fromsec, data_sections) &&
1167 (strncmp(fromsym, "__param", strlen("__param")) == 0))
1168 return 0;
1169
1170 /* Check for pattern 1a */
1171 if (strcmp(tosec, ".init.text") == 0 &&
1172 match(fromsec, data_sections) &&
1173 (strncmp(fromsym, "__param_ops_", strlen("__param_ops_")) == 0))
1174 return 0;
1175
1176 /* Check for pattern 2 */
1177 if (match(tosec, init_exit_sections) &&
1178 match(fromsec, data_sections) &&
1179 match(fromsym, mismatch->symbol_white_list))
1180 return 0;
1181
1182 /* Check for pattern 3 */
1183 if (match(fromsec, head_sections) &&
1184 match(tosec, init_sections))
1185 return 0;
1186
1187 /* Check for pattern 4 */
1188 if (match(tosym, linker_symbols))
1189 return 0;
1190
1191 /* Check for pattern 5 */
1192 if (match(fromsec, text_sections) &&
1193 match(tosec, init_sections) &&
1194 match(fromsym, optim_symbols))
1195 return 0;
1196
1197 return 1;
1198 }
1199
1200 /**
1201 * Find symbol based on relocation record info.
1202 * In some cases the symbol supplied is a valid symbol so
1203 * return refsym. If st_name != 0 we assume this is a valid symbol.
1204 * In other cases the symbol needs to be looked up in the symbol table
1205 * based on section and address.
1206 * **/
1207 static Elf_Sym *find_elf_symbol(struct elf_info *elf, Elf64_Sword addr,
1208 Elf_Sym *relsym)
1209 {
1210 Elf_Sym *sym;
1211 Elf_Sym *near = NULL;
1212 Elf64_Sword distance = 20;
1213 Elf64_Sword d;
1214 unsigned int relsym_secindex;
1215
1216 if (relsym->st_name != 0)
1217 return relsym;
1218
1219 relsym_secindex = get_secindex(elf, relsym);
1220 for (sym = elf->symtab_start; sym < elf->symtab_stop; sym++) {
1221 if (get_secindex(elf, sym) != relsym_secindex)
1222 continue;
1223 if (ELF_ST_TYPE(sym->st_info) == STT_SECTION)
1224 continue;
1225 if (sym->st_value == addr)
1226 return sym;
1227 /* Find a symbol nearby - addr are maybe negative */
1228 d = sym->st_value - addr;
1229 if (d < 0)
1230 d = addr - sym->st_value;
1231 if (d < distance) {
1232 distance = d;
1233 near = sym;
1234 }
1235 }
1236 /* We need a close match */
1237 if (distance < 20)
1238 return near;
1239 else
1240 return NULL;
1241 }
1242
1243 static inline int is_arm_mapping_symbol(const char *str)
1244 {
1245 return str[0] == '$' && strchr("axtd", str[1])
1246 && (str[2] == '\0' || str[2] == '.');
1247 }
1248
1249 /*
1250 * If there's no name there, ignore it; likewise, ignore it if it's
1251 * one of the magic symbols emitted used by current ARM tools.
1252 *
1253 * Otherwise if find_symbols_between() returns those symbols, they'll
1254 * fail the whitelist tests and cause lots of false alarms ... fixable
1255 * only by merging __exit and __init sections into __text, bloating
1256 * the kernel (which is especially evil on embedded platforms).
1257 */
1258 static inline int is_valid_name(struct elf_info *elf, Elf_Sym *sym)
1259 {
1260 const char *name = elf->strtab + sym->st_name;
1261
1262 if (!name || !strlen(name))
1263 return 0;
1264 return !is_arm_mapping_symbol(name);
1265 }
1266
1267 /*
1268 * Find symbols before or equal addr and after addr - in the section sec.
1269 * If we find two symbols with equal offset prefer one with a valid name.
1270 * The ELF format may have a better way to detect what type of symbol
1271 * it is, but this works for now.
1272 **/
1273 static Elf_Sym *find_elf_symbol2(struct elf_info *elf, Elf_Addr addr,
1274 const char *sec)
1275 {
1276 Elf_Sym *sym;
1277 Elf_Sym *near = NULL;
1278 Elf_Addr distance = ~0;
1279
1280 for (sym = elf->symtab_start; sym < elf->symtab_stop; sym++) {
1281 const char *symsec;
1282
1283 if (is_shndx_special(sym->st_shndx))
1284 continue;
1285 symsec = sec_name(elf, get_secindex(elf, sym));
1286 if (strcmp(symsec, sec) != 0)
1287 continue;
1288 if (!is_valid_name(elf, sym))
1289 continue;
1290 if (sym->st_value <= addr) {
1291 if ((addr - sym->st_value) < distance) {
1292 distance = addr - sym->st_value;
1293 near = sym;
1294 } else if ((addr - sym->st_value) == distance) {
1295 near = sym;
1296 }
1297 }
1298 }
1299 return near;
1300 }
1301
1302 /*
1303 * Convert a section name to the function/data attribute
1304 * .init.text => __init
1305 * .memexitconst => __memconst
1306 * etc.
1307 *
1308 * The memory of returned value has been allocated on a heap. The user of this
1309 * method should free it after usage.
1310 */
1311 static char *sec2annotation(const char *s)
1312 {
1313 if (match(s, init_exit_sections)) {
1314 char *p = NOFAIL(malloc(20));
1315 char *r = p;
1316
1317 *p++ = '_';
1318 *p++ = '_';
1319 if (*s == '.')
1320 s++;
1321 while (*s && *s != '.')
1322 *p++ = *s++;
1323 *p = '\0';
1324 if (*s == '.')
1325 s++;
1326 if (strstr(s, "rodata") != NULL)
1327 strcat(p, "const ");
1328 else if (strstr(s, "data") != NULL)
1329 strcat(p, "data ");
1330 else
1331 strcat(p, " ");
1332 return r;
1333 } else {
1334 return NOFAIL(strdup(""));
1335 }
1336 }
1337
1338 static int is_function(Elf_Sym *sym)
1339 {
1340 if (sym)
1341 return ELF_ST_TYPE(sym->st_info) == STT_FUNC;
1342 else
1343 return -1;
1344 }
1345
1346 static void print_section_list(const char * const list[20])
1347 {
1348 const char *const *s = list;
1349
1350 while (*s) {
1351 fprintf(stderr, "%s", *s);
1352 s++;
1353 if (*s)
1354 fprintf(stderr, ", ");
1355 }
1356 fprintf(stderr, "\n");
1357 }
1358
1359 static inline void get_pretty_name(int is_func, const char** name, const char** name_p)
1360 {
1361 switch (is_func) {
1362 case 0: *name = "variable"; *name_p = ""; break;
1363 case 1: *name = "function"; *name_p = "()"; break;
1364 default: *name = "(unknown reference)"; *name_p = ""; break;
1365 }
1366 }
1367
1368 /*
1369 * Print a warning about a section mismatch.
1370 * Try to find symbols near it so user can find it.
1371 * Check whitelist before warning - it may be a false positive.
1372 */
1373 static void report_sec_mismatch(const char *modname,
1374 const struct sectioncheck *mismatch,
1375 const char *fromsec,
1376 unsigned long long fromaddr,
1377 const char *fromsym,
1378 int from_is_func,
1379 const char *tosec, const char *tosym,
1380 int to_is_func)
1381 {
1382 const char *from, *from_p;
1383 const char *to, *to_p;
1384 char *prl_from;
1385 char *prl_to;
1386
1387 sec_mismatch_count++;
1388 if (!sec_mismatch_verbose)
1389 return;
1390
1391 get_pretty_name(from_is_func, &from, &from_p);
1392 get_pretty_name(to_is_func, &to, &to_p);
1393
1394 warn("%s(%s+0x%llx): Section mismatch in reference from the %s %s%s "
1395 "to the %s %s:%s%s\n",
1396 modname, fromsec, fromaddr, from, fromsym, from_p, to, tosec,
1397 tosym, to_p);
1398
1399 switch (mismatch->mismatch) {
1400 case TEXT_TO_ANY_INIT:
1401 prl_from = sec2annotation(fromsec);
1402 prl_to = sec2annotation(tosec);
1403 fprintf(stderr,
1404 "The function %s%s() references\n"
1405 "the %s %s%s%s.\n"
1406 "This is often because %s lacks a %s\n"
1407 "annotation or the annotation of %s is wrong.\n",
1408 prl_from, fromsym,
1409 to, prl_to, tosym, to_p,
1410 fromsym, prl_to, tosym);
1411 free(prl_from);
1412 free(prl_to);
1413 break;
1414 case DATA_TO_ANY_INIT: {
1415 prl_to = sec2annotation(tosec);
1416 fprintf(stderr,
1417 "The variable %s references\n"
1418 "the %s %s%s%s\n"
1419 "If the reference is valid then annotate the\n"
1420 "variable with __init* or __refdata (see linux/init.h) "
1421 "or name the variable:\n",
1422 fromsym, to, prl_to, tosym, to_p);
1423 print_section_list(mismatch->symbol_white_list);
1424 free(prl_to);
1425 break;
1426 }
1427 case TEXT_TO_ANY_EXIT:
1428 prl_to = sec2annotation(tosec);
1429 fprintf(stderr,
1430 "The function %s() references a %s in an exit section.\n"
1431 "Often the %s %s%s has valid usage outside the exit section\n"
1432 "and the fix is to remove the %sannotation of %s.\n",
1433 fromsym, to, to, tosym, to_p, prl_to, tosym);
1434 free(prl_to);
1435 break;
1436 case DATA_TO_ANY_EXIT: {
1437 prl_to = sec2annotation(tosec);
1438 fprintf(stderr,
1439 "The variable %s references\n"
1440 "the %s %s%s%s\n"
1441 "If the reference is valid then annotate the\n"
1442 "variable with __exit* (see linux/init.h) or "
1443 "name the variable:\n",
1444 fromsym, to, prl_to, tosym, to_p);
1445 print_section_list(mismatch->symbol_white_list);
1446 free(prl_to);
1447 break;
1448 }
1449 case XXXINIT_TO_SOME_INIT:
1450 case XXXEXIT_TO_SOME_EXIT:
1451 prl_from = sec2annotation(fromsec);
1452 prl_to = sec2annotation(tosec);
1453 fprintf(stderr,
1454 "The %s %s%s%s references\n"
1455 "a %s %s%s%s.\n"
1456 "If %s is only used by %s then\n"
1457 "annotate %s with a matching annotation.\n",
1458 from, prl_from, fromsym, from_p,
1459 to, prl_to, tosym, to_p,
1460 tosym, fromsym, tosym);
1461 free(prl_from);
1462 free(prl_to);
1463 break;
1464 case ANY_INIT_TO_ANY_EXIT:
1465 prl_from = sec2annotation(fromsec);
1466 prl_to = sec2annotation(tosec);
1467 fprintf(stderr,
1468 "The %s %s%s%s references\n"
1469 "a %s %s%s%s.\n"
1470 "This is often seen when error handling "
1471 "in the init function\n"
1472 "uses functionality in the exit path.\n"
1473 "The fix is often to remove the %sannotation of\n"
1474 "%s%s so it may be used outside an exit section.\n",
1475 from, prl_from, fromsym, from_p,
1476 to, prl_to, tosym, to_p,
1477 prl_to, tosym, to_p);
1478 free(prl_from);
1479 free(prl_to);
1480 break;
1481 case ANY_EXIT_TO_ANY_INIT:
1482 prl_from = sec2annotation(fromsec);
1483 prl_to = sec2annotation(tosec);
1484 fprintf(stderr,
1485 "The %s %s%s%s references\n"
1486 "a %s %s%s%s.\n"
1487 "This is often seen when error handling "
1488 "in the exit function\n"
1489 "uses functionality in the init path.\n"
1490 "The fix is often to remove the %sannotation of\n"
1491 "%s%s so it may be used outside an init section.\n",
1492 from, prl_from, fromsym, from_p,
1493 to, prl_to, tosym, to_p,
1494 prl_to, tosym, to_p);
1495 free(prl_from);
1496 free(prl_to);
1497 break;
1498 case EXPORT_TO_INIT_EXIT:
1499 prl_to = sec2annotation(tosec);
1500 fprintf(stderr,
1501 "The symbol %s is exported and annotated %s\n"
1502 "Fix this by removing the %sannotation of %s "
1503 "or drop the export.\n",
1504 tosym, prl_to, prl_to, tosym);
1505 free(prl_to);
1506 break;
1507 case EXTABLE_TO_NON_TEXT:
1508 fatal("There's a special handler for this mismatch type, "
1509 "we should never get here.");
1510 break;
1511 }
1512 fprintf(stderr, "\n");
1513 }
1514
1515 static void default_mismatch_handler(const char *modname, struct elf_info *elf,
1516 const struct sectioncheck* const mismatch,
1517 Elf_Rela *r, Elf_Sym *sym, const char *fromsec)
1518 {
1519 const char *tosec;
1520 Elf_Sym *to;
1521 Elf_Sym *from;
1522 const char *tosym;
1523 const char *fromsym;
1524
1525 from = find_elf_symbol2(elf, r->r_offset, fromsec);
1526 fromsym = sym_name(elf, from);
1527
1528 if (!strncmp(fromsym, "reference___initcall",
1529 sizeof("reference___initcall")-1))
1530 return;
1531
1532 tosec = sec_name(elf, get_secindex(elf, sym));
1533 to = find_elf_symbol(elf, r->r_addend, sym);
1534 tosym = sym_name(elf, to);
1535
1536 /* check whitelist - we may ignore it */
1537 if (secref_whitelist(mismatch,
1538 fromsec, fromsym, tosec, tosym)) {
1539 report_sec_mismatch(modname, mismatch,
1540 fromsec, r->r_offset, fromsym,
1541 is_function(from), tosec, tosym,
1542 is_function(to));
1543 }
1544 }
1545
1546 static int is_executable_section(struct elf_info* elf, unsigned int section_index)
1547 {
1548 if (section_index > elf->num_sections)
1549 fatal("section_index is outside elf->num_sections!\n");
1550
1551 return ((elf->sechdrs[section_index].sh_flags & SHF_EXECINSTR) == SHF_EXECINSTR);
1552 }
1553
1554 /*
1555 * We rely on a gross hack in section_rel[a]() calling find_extable_entry_size()
1556 * to know the sizeof(struct exception_table_entry) for the target architecture.
1557 */
1558 static unsigned int extable_entry_size = 0;
1559 static void find_extable_entry_size(const char* const sec, const Elf_Rela* r)
1560 {
1561 /*
1562 * If we're currently checking the second relocation within __ex_table,
1563 * that relocation offset tells us the offsetof(struct
1564 * exception_table_entry, fixup) which is equal to sizeof(struct
1565 * exception_table_entry) divided by two. We use that to our advantage
1566 * since there's no portable way to get that size as every architecture
1567 * seems to go with different sized types. Not pretty but better than
1568 * hard-coding the size for every architecture..
1569 */
1570 if (!extable_entry_size)
1571 extable_entry_size = r->r_offset * 2;
1572 }
1573
1574 static inline bool is_extable_fault_address(Elf_Rela *r)
1575 {
1576 /*
1577 * extable_entry_size is only discovered after we've handled the
1578 * _second_ relocation in __ex_table, so only abort when we're not
1579 * handling the first reloc and extable_entry_size is zero.
1580 */
1581 if (r->r_offset && extable_entry_size == 0)
1582 fatal("extable_entry size hasn't been discovered!\n");
1583
1584 return ((r->r_offset == 0) ||
1585 (r->r_offset % extable_entry_size == 0));
1586 }
1587
1588 #define is_second_extable_reloc(Start, Cur, Sec) \
1589 (((Cur) == (Start) + 1) && (strcmp("__ex_table", (Sec)) == 0))
1590
1591 static void report_extable_warnings(const char* modname, struct elf_info* elf,
1592 const struct sectioncheck* const mismatch,
1593 Elf_Rela* r, Elf_Sym* sym,
1594 const char* fromsec, const char* tosec)
1595 {
1596 Elf_Sym* fromsym = find_elf_symbol2(elf, r->r_offset, fromsec);
1597 const char* fromsym_name = sym_name(elf, fromsym);
1598 Elf_Sym* tosym = find_elf_symbol(elf, r->r_addend, sym);
1599 const char* tosym_name = sym_name(elf, tosym);
1600 const char* from_pretty_name;
1601 const char* from_pretty_name_p;
1602 const char* to_pretty_name;
1603 const char* to_pretty_name_p;
1604
1605 get_pretty_name(is_function(fromsym),
1606 &from_pretty_name, &from_pretty_name_p);
1607 get_pretty_name(is_function(tosym),
1608 &to_pretty_name, &to_pretty_name_p);
1609
1610 warn("%s(%s+0x%lx): Section mismatch in reference"
1611 " from the %s %s%s to the %s %s:%s%s\n",
1612 modname, fromsec, (long)r->r_offset, from_pretty_name,
1613 fromsym_name, from_pretty_name_p,
1614 to_pretty_name, tosec, tosym_name, to_pretty_name_p);
1615
1616 if (!match(tosec, mismatch->bad_tosec) &&
1617 is_executable_section(elf, get_secindex(elf, sym)))
1618 fprintf(stderr,
1619 "The relocation at %s+0x%lx references\n"
1620 "section \"%s\" which is not in the list of\n"
1621 "authorized sections. If you're adding a new section\n"
1622 "and/or if this reference is valid, add \"%s\" to the\n"
1623 "list of authorized sections to jump to on fault.\n"
1624 "This can be achieved by adding \"%s\" to \n"
1625 "OTHER_TEXT_SECTIONS in scripts/mod/modpost.c.\n",
1626 fromsec, (long)r->r_offset, tosec, tosec, tosec);
1627 }
1628
1629 static void extable_mismatch_handler(const char* modname, struct elf_info *elf,
1630 const struct sectioncheck* const mismatch,
1631 Elf_Rela* r, Elf_Sym* sym,
1632 const char *fromsec)
1633 {
1634 const char* tosec = sec_name(elf, get_secindex(elf, sym));
1635
1636 sec_mismatch_count++;
1637
1638 if (sec_mismatch_verbose)
1639 report_extable_warnings(modname, elf, mismatch, r, sym,
1640 fromsec, tosec);
1641
1642 if (match(tosec, mismatch->bad_tosec))
1643 fatal("The relocation at %s+0x%lx references\n"
1644 "section \"%s\" which is black-listed.\n"
1645 "Something is seriously wrong and should be fixed.\n"
1646 "You might get more information about where this is\n"
1647 "coming from by using scripts/check_extable.sh %s\n",
1648 fromsec, (long)r->r_offset, tosec, modname);
1649 else if (!is_executable_section(elf, get_secindex(elf, sym))) {
1650 if (is_extable_fault_address(r))
1651 fatal("The relocation at %s+0x%lx references\n"
1652 "section \"%s\" which is not executable, IOW\n"
1653 "it is not possible for the kernel to fault\n"
1654 "at that address. Something is seriously wrong\n"
1655 "and should be fixed.\n",
1656 fromsec, (long)r->r_offset, tosec);
1657 else
1658 fatal("The relocation at %s+0x%lx references\n"
1659 "section \"%s\" which is not executable, IOW\n"
1660 "the kernel will fault if it ever tries to\n"
1661 "jump to it. Something is seriously wrong\n"
1662 "and should be fixed.\n",
1663 fromsec, (long)r->r_offset, tosec);
1664 }
1665 }
1666
1667 static void check_section_mismatch(const char *modname, struct elf_info *elf,
1668 Elf_Rela *r, Elf_Sym *sym, const char *fromsec)
1669 {
1670 const char *tosec = sec_name(elf, get_secindex(elf, sym));;
1671 const struct sectioncheck *mismatch = section_mismatch(fromsec, tosec);
1672
1673 if (mismatch) {
1674 if (mismatch->handler)
1675 mismatch->handler(modname, elf, mismatch,
1676 r, sym, fromsec);
1677 else
1678 default_mismatch_handler(modname, elf, mismatch,
1679 r, sym, fromsec);
1680 }
1681 }
1682
1683 static unsigned int *reloc_location(struct elf_info *elf,
1684 Elf_Shdr *sechdr, Elf_Rela *r)
1685 {
1686 Elf_Shdr *sechdrs = elf->sechdrs;
1687 int section = sechdr->sh_info;
1688
1689 return (void *)elf->hdr + sechdrs[section].sh_offset +
1690 r->r_offset;
1691 }
1692
1693 static int addend_386_rel(struct elf_info *elf, Elf_Shdr *sechdr, Elf_Rela *r)
1694 {
1695 unsigned int r_typ = ELF_R_TYPE(r->r_info);
1696 unsigned int *location = reloc_location(elf, sechdr, r);
1697
1698 switch (r_typ) {
1699 case R_386_32:
1700 r->r_addend = TO_NATIVE(*location);
1701 break;
1702 case R_386_PC32:
1703 r->r_addend = TO_NATIVE(*location) + 4;
1704 /* For CONFIG_RELOCATABLE=y */
1705 if (elf->hdr->e_type == ET_EXEC)
1706 r->r_addend += r->r_offset;
1707 break;
1708 }
1709 return 0;
1710 }
1711
1712 #ifndef R_ARM_CALL
1713 #define R_ARM_CALL 28
1714 #endif
1715 #ifndef R_ARM_JUMP24
1716 #define R_ARM_JUMP24 29
1717 #endif
1718
1719 #ifndef R_ARM_THM_CALL
1720 #define R_ARM_THM_CALL 10
1721 #endif
1722 #ifndef R_ARM_THM_JUMP24
1723 #define R_ARM_THM_JUMP24 30
1724 #endif
1725 #ifndef R_ARM_THM_JUMP19
1726 #define R_ARM_THM_JUMP19 51
1727 #endif
1728
1729 static int addend_arm_rel(struct elf_info *elf, Elf_Shdr *sechdr, Elf_Rela *r)
1730 {
1731 unsigned int r_typ = ELF_R_TYPE(r->r_info);
1732
1733 switch (r_typ) {
1734 case R_ARM_ABS32:
1735 /* From ARM ABI: (S + A) | T */
1736 r->r_addend = (int)(long)
1737 (elf->symtab_start + ELF_R_SYM(r->r_info));
1738 break;
1739 case R_ARM_PC24:
1740 case R_ARM_CALL:
1741 case R_ARM_JUMP24:
1742 case R_ARM_THM_CALL:
1743 case R_ARM_THM_JUMP24:
1744 case R_ARM_THM_JUMP19:
1745 /* From ARM ABI: ((S + A) | T) - P */
1746 r->r_addend = (int)(long)(elf->hdr +
1747 sechdr->sh_offset +
1748 (r->r_offset - sechdr->sh_addr));
1749 break;
1750 default:
1751 return 1;
1752 }
1753 return 0;
1754 }
1755
1756 static int addend_mips_rel(struct elf_info *elf, Elf_Shdr *sechdr, Elf_Rela *r)
1757 {
1758 unsigned int r_typ = ELF_R_TYPE(r->r_info);
1759 unsigned int *location = reloc_location(elf, sechdr, r);
1760 unsigned int inst;
1761
1762 if (r_typ == R_MIPS_HI16)
1763 return 1; /* skip this */
1764 inst = TO_NATIVE(*location);
1765 switch (r_typ) {
1766 case R_MIPS_LO16:
1767 r->r_addend = inst & 0xffff;
1768 break;
1769 case R_MIPS_26:
1770 r->r_addend = (inst & 0x03ffffff) << 2;
1771 break;
1772 case R_MIPS_32:
1773 r->r_addend = inst;
1774 break;
1775 }
1776 return 0;
1777 }
1778
1779 static void section_rela(const char *modname, struct elf_info *elf,
1780 Elf_Shdr *sechdr)
1781 {
1782 Elf_Sym *sym;
1783 Elf_Rela *rela;
1784 Elf_Rela r;
1785 unsigned int r_sym;
1786 const char *fromsec;
1787
1788 Elf_Rela *start = (void *)elf->hdr + sechdr->sh_offset;
1789 Elf_Rela *stop = (void *)start + sechdr->sh_size;
1790
1791 fromsec = sech_name(elf, sechdr);
1792 fromsec += strlen(".rela");
1793 /* if from section (name) is know good then skip it */
1794 if (match(fromsec, section_white_list))
1795 return;
1796
1797 for (rela = start; rela < stop; rela++) {
1798 r.r_offset = TO_NATIVE(rela->r_offset);
1799 #if KERNEL_ELFCLASS == ELFCLASS64
1800 if (elf->hdr->e_machine == EM_MIPS) {
1801 unsigned int r_typ;
1802 r_sym = ELF64_MIPS_R_SYM(rela->r_info);
1803 r_sym = TO_NATIVE(r_sym);
1804 r_typ = ELF64_MIPS_R_TYPE(rela->r_info);
1805 r.r_info = ELF64_R_INFO(r_sym, r_typ);
1806 } else {
1807 r.r_info = TO_NATIVE(rela->r_info);
1808 r_sym = ELF_R_SYM(r.r_info);
1809 }
1810 #else
1811 r.r_info = TO_NATIVE(rela->r_info);
1812 r_sym = ELF_R_SYM(r.r_info);
1813 #endif
1814 r.r_addend = TO_NATIVE(rela->r_addend);
1815 sym = elf->symtab_start + r_sym;
1816 /* Skip special sections */
1817 if (is_shndx_special(sym->st_shndx))
1818 continue;
1819 if (is_second_extable_reloc(start, rela, fromsec))
1820 find_extable_entry_size(fromsec, &r);
1821 check_section_mismatch(modname, elf, &r, sym, fromsec);
1822 }
1823 }
1824
1825 static void section_rel(const char *modname, struct elf_info *elf,
1826 Elf_Shdr *sechdr)
1827 {
1828 Elf_Sym *sym;
1829 Elf_Rel *rel;
1830 Elf_Rela r;
1831 unsigned int r_sym;
1832 const char *fromsec;
1833
1834 Elf_Rel *start = (void *)elf->hdr + sechdr->sh_offset;
1835 Elf_Rel *stop = (void *)start + sechdr->sh_size;
1836
1837 fromsec = sech_name(elf, sechdr);
1838 fromsec += strlen(".rel");
1839 /* if from section (name) is know good then skip it */
1840 if (match(fromsec, section_white_list))
1841 return;
1842
1843 for (rel = start; rel < stop; rel++) {
1844 r.r_offset = TO_NATIVE(rel->r_offset);
1845 #if KERNEL_ELFCLASS == ELFCLASS64
1846 if (elf->hdr->e_machine == EM_MIPS) {
1847 unsigned int r_typ;
1848 r_sym = ELF64_MIPS_R_SYM(rel->r_info);
1849 r_sym = TO_NATIVE(r_sym);
1850 r_typ = ELF64_MIPS_R_TYPE(rel->r_info);
1851 r.r_info = ELF64_R_INFO(r_sym, r_typ);
1852 } else {
1853 r.r_info = TO_NATIVE(rel->r_info);
1854 r_sym = ELF_R_SYM(r.r_info);
1855 }
1856 #else
1857 r.r_info = TO_NATIVE(rel->r_info);
1858 r_sym = ELF_R_SYM(r.r_info);
1859 #endif
1860 r.r_addend = 0;
1861 switch (elf->hdr->e_machine) {
1862 case EM_386:
1863 if (addend_386_rel(elf, sechdr, &r))
1864 continue;
1865 break;
1866 case EM_ARM:
1867 if (addend_arm_rel(elf, sechdr, &r))
1868 continue;
1869 break;
1870 case EM_MIPS:
1871 if (addend_mips_rel(elf, sechdr, &r))
1872 continue;
1873 break;
1874 }
1875 sym = elf->symtab_start + r_sym;
1876 /* Skip special sections */
1877 if (is_shndx_special(sym->st_shndx))
1878 continue;
1879 if (is_second_extable_reloc(start, rel, fromsec))
1880 find_extable_entry_size(fromsec, &r);
1881 check_section_mismatch(modname, elf, &r, sym, fromsec);
1882 }
1883 }
1884
1885 /**
1886 * A module includes a number of sections that are discarded
1887 * either when loaded or when used as built-in.
1888 * For loaded modules all functions marked __init and all data
1889 * marked __initdata will be discarded when the module has been initialized.
1890 * Likewise for modules used built-in the sections marked __exit
1891 * are discarded because __exit marked function are supposed to be called
1892 * only when a module is unloaded which never happens for built-in modules.
1893 * The check_sec_ref() function traverses all relocation records
1894 * to find all references to a section that reference a section that will
1895 * be discarded and warns about it.
1896 **/
1897 static void check_sec_ref(struct module *mod, const char *modname,
1898 struct elf_info *elf)
1899 {
1900 int i;
1901 Elf_Shdr *sechdrs = elf->sechdrs;
1902
1903 /* Walk through all sections */
1904 for (i = 0; i < elf->num_sections; i++) {
1905 check_section(modname, elf, &elf->sechdrs[i]);
1906 /* We want to process only relocation sections and not .init */
1907 if (sechdrs[i].sh_type == SHT_RELA)
1908 section_rela(modname, elf, &elf->sechdrs[i]);
1909 else if (sechdrs[i].sh_type == SHT_REL)
1910 section_rel(modname, elf, &elf->sechdrs[i]);
1911 }
1912 }
1913
1914 static char *remove_dot(char *s)
1915 {
1916 size_t n = strcspn(s, ".");
1917
1918 if (n && s[n]) {
1919 size_t m = strspn(s + n + 1, "0123456789");
1920 if (m && (s[n + m] == '.' || s[n + m] == 0))
1921 s[n] = 0;
1922 }
1923 return s;
1924 }
1925
1926 static void read_symbols(char *modname)
1927 {
1928 const char *symname;
1929 char *version;
1930 char *license;
1931 struct module *mod;
1932 struct elf_info info = { };
1933 Elf_Sym *sym;
1934
1935 if (!parse_elf(&info, modname))
1936 return;
1937
1938 mod = new_module(modname);
1939
1940 /* When there's no vmlinux, don't print warnings about
1941 * unresolved symbols (since there'll be too many ;) */
1942 if (is_vmlinux(modname)) {
1943 have_vmlinux = 1;
1944 mod->skip = 1;
1945 }
1946
1947 license = get_modinfo(info.modinfo, info.modinfo_len, "license");
1948 if (info.modinfo && !license && !is_vmlinux(modname))
1949 warn("modpost: missing MODULE_LICENSE() in %s\n"
1950 "see include/linux/module.h for "
1951 "more information\n", modname);
1952 while (license) {
1953 if (license_is_gpl_compatible(license))
1954 mod->gpl_compatible = 1;
1955 else {
1956 mod->gpl_compatible = 0;
1957 break;
1958 }
1959 license = get_next_modinfo(info.modinfo, info.modinfo_len,
1960 "license", license);
1961 }
1962
1963 for (sym = info.symtab_start; sym < info.symtab_stop; sym++) {
1964 symname = remove_dot(info.strtab + sym->st_name);
1965
1966 handle_modversions(mod, &info, sym, symname);
1967 handle_moddevtable(mod, &info, sym, symname);
1968 }
1969 if (!is_vmlinux(modname) ||
1970 (is_vmlinux(modname) && vmlinux_section_warnings))
1971 check_sec_ref(mod, modname, &info);
1972
1973 version = get_modinfo(info.modinfo, info.modinfo_len, "version");
1974 if (version)
1975 maybe_frob_rcs_version(modname, version, info.modinfo,
1976 version - (char *)info.hdr);
1977 if (version || (all_versions && !is_vmlinux(modname)))
1978 get_src_version(modname, mod->srcversion,
1979 sizeof(mod->srcversion)-1);
1980
1981 parse_elf_finish(&info);
1982
1983 /* Our trick to get versioning for module struct etc. - it's
1984 * never passed as an argument to an exported function, so
1985 * the automatic versioning doesn't pick it up, but it's really
1986 * important anyhow */
1987 if (modversions)
1988 mod->unres = alloc_symbol("module_layout", 0, mod->unres);
1989 }
1990
1991 static void read_symbols_from_files(const char *filename)
1992 {
1993 FILE *in = stdin;
1994 char fname[PATH_MAX];
1995
1996 if (strcmp(filename, "-") != 0) {
1997 in = fopen(filename, "r");
1998 if (!in)
1999 fatal("Can't open filenames file %s: %m", filename);
2000 }
2001
2002 while (fgets(fname, PATH_MAX, in) != NULL) {
2003 if (strends(fname, "\n"))
2004 fname[strlen(fname)-1] = '\0';
2005 read_symbols(fname);
2006 }
2007
2008 if (in != stdin)
2009 fclose(in);
2010 }
2011
2012 #define SZ 500
2013
2014 /* We first write the generated file into memory using the
2015 * following helper, then compare to the file on disk and
2016 * only update the later if anything changed */
2017
2018 void __attribute__((format(printf, 2, 3))) buf_printf(struct buffer *buf,
2019 const char *fmt, ...)
2020 {
2021 char tmp[SZ];
2022 int len;
2023 va_list ap;
2024
2025 va_start(ap, fmt);
2026 len = vsnprintf(tmp, SZ, fmt, ap);
2027 buf_write(buf, tmp, len);
2028 va_end(ap);
2029 }
2030
2031 void buf_write(struct buffer *buf, const char *s, int len)
2032 {
2033 if (buf->size - buf->pos < len) {
2034 buf->size += len + SZ;
2035 buf->p = NOFAIL(realloc(buf->p, buf->size));
2036 }
2037 strncpy(buf->p + buf->pos, s, len);
2038 buf->pos += len;
2039 }
2040
2041 static void check_for_gpl_usage(enum export exp, const char *m, const char *s)
2042 {
2043 const char *e = is_vmlinux(m) ?"":".ko";
2044
2045 switch (exp) {
2046 case export_gpl:
2047 fatal("modpost: GPL-incompatible module %s%s "
2048 "uses GPL-only symbol '%s'\n", m, e, s);
2049 break;
2050 case export_unused_gpl:
2051 fatal("modpost: GPL-incompatible module %s%s "
2052 "uses GPL-only symbol marked UNUSED '%s'\n", m, e, s);
2053 break;
2054 case export_gpl_future:
2055 warn("modpost: GPL-incompatible module %s%s "
2056 "uses future GPL-only symbol '%s'\n", m, e, s);
2057 break;
2058 case export_plain:
2059 case export_unused:
2060 case export_unknown:
2061 /* ignore */
2062 break;
2063 }
2064 }
2065
2066 static void check_for_unused(enum export exp, const char *m, const char *s)
2067 {
2068 const char *e = is_vmlinux(m) ?"":".ko";
2069
2070 switch (exp) {
2071 case export_unused:
2072 case export_unused_gpl:
2073 warn("modpost: module %s%s "
2074 "uses symbol '%s' marked UNUSED\n", m, e, s);
2075 break;
2076 default:
2077 /* ignore */
2078 break;
2079 }
2080 }
2081
2082 static void check_exports(struct module *mod)
2083 {
2084 struct symbol *s, *exp;
2085
2086 for (s = mod->unres; s; s = s->next) {
2087 const char *basename;
2088 exp = find_symbol(s->name);
2089 if (!exp || exp->module == mod)
2090 continue;
2091 basename = strrchr(mod->name, '/');
2092 if (basename)
2093 basename++;
2094 else
2095 basename = mod->name;
2096 if (!mod->gpl_compatible)
2097 check_for_gpl_usage(exp->export, basename, exp->name);
2098 check_for_unused(exp->export, basename, exp->name);
2099 }
2100 }
2101
2102 /**
2103 * Header for the generated file
2104 **/
2105 static void add_header(struct buffer *b, struct module *mod)
2106 {
2107 buf_printf(b, "#include <linux/module.h>\n");
2108 buf_printf(b, "#include <linux/vermagic.h>\n");
2109 buf_printf(b, "#include <linux/compiler.h>\n");
2110 buf_printf(b, "\n");
2111 buf_printf(b, "MODULE_INFO(vermagic, VERMAGIC_STRING);\n");
2112 buf_printf(b, "\n");
2113 buf_printf(b, "__visible struct module __this_module\n");
2114 buf_printf(b, "__attribute__((section(\".gnu.linkonce.this_module\"))) = {\n");
2115 buf_printf(b, "\t.name = KBUILD_MODNAME,\n");
2116 if (mod->has_init)
2117 buf_printf(b, "\t.init = init_module,\n");
2118 if (mod->has_cleanup)
2119 buf_printf(b, "#ifdef CONFIG_MODULE_UNLOAD\n"
2120 "\t.exit = cleanup_module,\n"
2121 "#endif\n");
2122 buf_printf(b, "\t.arch = MODULE_ARCH_INIT,\n");
2123 buf_printf(b, "};\n");
2124 }
2125
2126 static void add_intree_flag(struct buffer *b, int is_intree)
2127 {
2128 if (is_intree)
2129 buf_printf(b, "\nMODULE_INFO(intree, \"Y\");\n");
2130 }
2131
2132 /* Cannot check for assembler */
2133 static void add_retpoline(struct buffer *b)
2134 {
2135 buf_printf(b, "\n#ifdef RETPOLINE\n");
2136 buf_printf(b, "MODULE_INFO(retpoline, \"Y\");\n");
2137 buf_printf(b, "#endif\n");
2138 }
2139
2140 static void add_staging_flag(struct buffer *b, const char *name)
2141 {
2142 static const char *staging_dir = "drivers/staging";
2143
2144 if (strncmp(staging_dir, name, strlen(staging_dir)) == 0)
2145 buf_printf(b, "\nMODULE_INFO(staging, \"Y\");\n");
2146 }
2147
2148 /* In kernel, this size is defined in linux/module.h;
2149 * here we use Elf_Addr instead of long for covering cross-compile
2150 */
2151 #define MODULE_NAME_LEN (64 - sizeof(Elf_Addr))
2152
2153 /**
2154 * Record CRCs for unresolved symbols
2155 **/
2156 static int add_versions(struct buffer *b, struct module *mod)
2157 {
2158 struct symbol *s, *exp;
2159 int err = 0;
2160
2161 for (s = mod->unres; s; s = s->next) {
2162 exp = find_symbol(s->name);
2163 if (!exp || exp->module == mod) {
2164 if (have_vmlinux && !s->weak) {
2165 if (warn_unresolved) {
2166 warn("\"%s\" [%s.ko] undefined!\n",
2167 s->name, mod->name);
2168 } else {
2169 merror("\"%s\" [%s.ko] undefined!\n",
2170 s->name, mod->name);
2171 err = 1;
2172 }
2173 }
2174 continue;
2175 }
2176 s->module = exp->module;
2177 s->crc_valid = exp->crc_valid;
2178 s->crc = exp->crc;
2179 }
2180
2181 if (!modversions)
2182 return err;
2183
2184 buf_printf(b, "\n");
2185 buf_printf(b, "static const struct modversion_info ____versions[]\n");
2186 buf_printf(b, "__used\n");
2187 buf_printf(b, "__attribute__((section(\"__versions\"))) = {\n");
2188
2189 for (s = mod->unres; s; s = s->next) {
2190 if (!s->module)
2191 continue;
2192 if (!s->crc_valid) {
2193 warn("\"%s\" [%s.ko] has no CRC!\n",
2194 s->name, mod->name);
2195 continue;
2196 }
2197 if (strlen(s->name) >= MODULE_NAME_LEN) {
2198 merror("too long symbol \"%s\" [%s.ko]\n",
2199 s->name, mod->name);
2200 err = 1;
2201 break;
2202 }
2203 buf_printf(b, "\t{ %#8x, __VMLINUX_SYMBOL_STR(%s) },\n",
2204 s->crc, s->name);
2205 }
2206
2207 buf_printf(b, "};\n");
2208
2209 return err;
2210 }
2211
2212 static void add_depends(struct buffer *b, struct module *mod,
2213 struct module *modules)
2214 {
2215 struct symbol *s;
2216 struct module *m;
2217 int first = 1;
2218
2219 for (m = modules; m; m = m->next)
2220 m->seen = is_vmlinux(m->name);
2221
2222 buf_printf(b, "\n");
2223 buf_printf(b, "static const char __module_depends[]\n");
2224 buf_printf(b, "__used\n");
2225 buf_printf(b, "__attribute__((section(\".modinfo\"))) =\n");
2226 buf_printf(b, "\"depends=");
2227 for (s = mod->unres; s; s = s->next) {
2228 const char *p;
2229 if (!s->module)
2230 continue;
2231
2232 if (s->module->seen)
2233 continue;
2234
2235 s->module->seen = 1;
2236 p = strrchr(s->module->name, '/');
2237 if (p)
2238 p++;
2239 else
2240 p = s->module->name;
2241 buf_printf(b, "%s%s", first ? "" : ",", p);
2242 first = 0;
2243 }
2244 buf_printf(b, "\";\n");
2245 }
2246
2247 static void add_srcversion(struct buffer *b, struct module *mod)
2248 {
2249 if (mod->srcversion[0]) {
2250 buf_printf(b, "\n");
2251 buf_printf(b, "MODULE_INFO(srcversion, \"%s\");\n",
2252 mod->srcversion);
2253 }
2254 }
2255
2256 static void write_if_changed(struct buffer *b, const char *fname)
2257 {
2258 char *tmp;
2259 FILE *file;
2260 struct stat st;
2261
2262 file = fopen(fname, "r");
2263 if (!file)
2264 goto write;
2265
2266 if (fstat(fileno(file), &st) < 0)
2267 goto close_write;
2268
2269 if (st.st_size != b->pos)
2270 goto close_write;
2271
2272 tmp = NOFAIL(malloc(b->pos));
2273 if (fread(tmp, 1, b->pos, file) != b->pos)
2274 goto free_write;
2275
2276 if (memcmp(tmp, b->p, b->pos) != 0)
2277 goto free_write;
2278
2279 free(tmp);
2280 fclose(file);
2281 return;
2282
2283 free_write:
2284 free(tmp);
2285 close_write:
2286 fclose(file);
2287 write:
2288 file = fopen(fname, "w");
2289 if (!file) {
2290 perror(fname);
2291 exit(1);
2292 }
2293 if (fwrite(b->p, 1, b->pos, file) != b->pos) {
2294 perror(fname);
2295 exit(1);
2296 }
2297 fclose(file);
2298 }
2299
2300 /* parse Module.symvers file. line format:
2301 * 0x12345678<tab>symbol<tab>module[[<tab>export]<tab>something]
2302 **/
2303 static void read_dump(const char *fname, unsigned int kernel)
2304 {
2305 unsigned long size, pos = 0;
2306 void *file = grab_file(fname, &size);
2307 char *line;
2308
2309 if (!file)
2310 /* No symbol versions, silently ignore */
2311 return;
2312
2313 while ((line = get_next_line(&pos, file, size))) {
2314 char *symname, *modname, *d, *export, *end;
2315 unsigned int crc;
2316 struct module *mod;
2317 struct symbol *s;
2318
2319 if (!(symname = strchr(line, '\t')))
2320 goto fail;
2321 *symname++ = '\0';
2322 if (!(modname = strchr(symname, '\t')))
2323 goto fail;
2324 *modname++ = '\0';
2325 if ((export = strchr(modname, '\t')) != NULL)
2326 *export++ = '\0';
2327 if (export && ((end = strchr(export, '\t')) != NULL))
2328 *end = '\0';
2329 crc = strtoul(line, &d, 16);
2330 if (*symname == '\0' || *modname == '\0' || *d != '\0')
2331 goto fail;
2332 mod = find_module(modname);
2333 if (!mod) {
2334 if (is_vmlinux(modname))
2335 have_vmlinux = 1;
2336 mod = new_module(modname);
2337 mod->skip = 1;
2338 }
2339 s = sym_add_exported(symname, mod, export_no(export));
2340 s->kernel = kernel;
2341 s->preloaded = 1;
2342 sym_update_crc(symname, mod, crc, export_no(export));
2343 }
2344 release_file(file, size);
2345 return;
2346 fail:
2347 release_file(file, size);
2348 fatal("parse error in symbol dump file\n");
2349 }
2350
2351 /* For normal builds always dump all symbols.
2352 * For external modules only dump symbols
2353 * that are not read from kernel Module.symvers.
2354 **/
2355 static int dump_sym(struct symbol *sym)
2356 {
2357 if (!external_module)
2358 return 1;
2359 if (sym->vmlinux || sym->kernel)
2360 return 0;
2361 return 1;
2362 }
2363
2364 static void write_dump(const char *fname)
2365 {
2366 struct buffer buf = { };
2367 struct symbol *symbol;
2368 int n;
2369
2370 for (n = 0; n < SYMBOL_HASH_SIZE ; n++) {
2371 symbol = symbolhash[n];
2372 while (symbol) {
2373 if (dump_sym(symbol))
2374 buf_printf(&buf, "0x%08x\t%s\t%s\t%s\n",
2375 symbol->crc, symbol->name,
2376 symbol->module->name,
2377 export_str(symbol->export));
2378 symbol = symbol->next;
2379 }
2380 }
2381 write_if_changed(&buf, fname);
2382 }
2383
2384 struct ext_sym_list {
2385 struct ext_sym_list *next;
2386 const char *file;
2387 };
2388
2389 int main(int argc, char **argv)
2390 {
2391 struct module *mod;
2392 struct buffer buf = { };
2393 char *kernel_read = NULL, *module_read = NULL;
2394 char *dump_write = NULL, *files_source = NULL;
2395 int opt;
2396 int err;
2397 struct ext_sym_list *extsym_iter;
2398 struct ext_sym_list *extsym_start = NULL;
2399
2400 while ((opt = getopt(argc, argv, "i:I:e:mnsST:o:awM:K:E")) != -1) {
2401 switch (opt) {
2402 case 'i':
2403 kernel_read = optarg;
2404 break;
2405 case 'I':
2406 module_read = optarg;
2407 external_module = 1;
2408 break;
2409 case 'e':
2410 external_module = 1;
2411 extsym_iter =
2412 NOFAIL(malloc(sizeof(*extsym_iter)));
2413 extsym_iter->next = extsym_start;
2414 extsym_iter->file = optarg;
2415 extsym_start = extsym_iter;
2416 break;
2417 case 'm':
2418 modversions = 1;
2419 break;
2420 case 'n':
2421 ignore_missing_files = 1;
2422 break;
2423 case 'o':
2424 dump_write = optarg;
2425 break;
2426 case 'a':
2427 all_versions = 1;
2428 break;
2429 case 's':
2430 vmlinux_section_warnings = 0;
2431 break;
2432 case 'S':
2433 sec_mismatch_verbose = 0;
2434 break;
2435 case 'T':
2436 files_source = optarg;
2437 break;
2438 case 'w':
2439 warn_unresolved = 1;
2440 break;
2441 case 'E':
2442 sec_mismatch_fatal = 1;
2443 break;
2444 default:
2445 exit(1);
2446 }
2447 }
2448
2449 if (kernel_read)
2450 read_dump(kernel_read, 1);
2451 if (module_read)
2452 read_dump(module_read, 0);
2453 while (extsym_start) {
2454 read_dump(extsym_start->file, 0);
2455 extsym_iter = extsym_start->next;
2456 free(extsym_start);
2457 extsym_start = extsym_iter;
2458 }
2459
2460 while (optind < argc)
2461 read_symbols(argv[optind++]);
2462
2463 if (files_source)
2464 read_symbols_from_files(files_source);
2465
2466 for (mod = modules; mod; mod = mod->next) {
2467 if (mod->skip)
2468 continue;
2469 check_exports(mod);
2470 }
2471
2472 err = 0;
2473
2474 for (mod = modules; mod; mod = mod->next) {
2475 char fname[PATH_MAX];
2476
2477 if (mod->skip)
2478 continue;
2479
2480 buf.pos = 0;
2481
2482 add_header(&buf, mod);
2483 add_intree_flag(&buf, !external_module);
2484 add_retpoline(&buf);
2485 add_staging_flag(&buf, mod->name);
2486 err |= add_versions(&buf, mod);
2487 add_depends(&buf, mod, modules);
2488 add_moddevtable(&buf, mod);
2489 add_srcversion(&buf, mod);
2490
2491 sprintf(fname, "%s.mod.c", mod->name);
2492 write_if_changed(&buf, fname);
2493 }
2494 if (dump_write)
2495 write_dump(dump_write);
2496 if (sec_mismatch_count) {
2497 if (!sec_mismatch_verbose) {
2498 warn("modpost: Found %d section mismatch(es).\n"
2499 "To see full details build your kernel with:\n"
2500 "'make CONFIG_DEBUG_SECTION_MISMATCH=y'\n",
2501 sec_mismatch_count);
2502 }
2503 if (sec_mismatch_fatal) {
2504 fatal("modpost: Section mismatches detected.\n"
2505 "Set CONFIG_SECTION_MISMATCH_WARN_ONLY=y to allow them.\n");
2506 }
2507 }
2508
2509 return err;
2510 }
Linux with added FPC-III support