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