?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
drm/nouveau: fix kernel-doc comments
[drm/drm-misc.git] / scripts / mod / modpost.c
blobfb787a5715f5e8b37713162979ca45355770dc73
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 <fnmatch.h>
17 #include <stdio.h>
18 #include <ctype.h>
19 #include <string.h>
20 #include <limits.h>
21 #include <stdbool.h>
22 #include <errno.h>
23
24 #include <hash.h>
25 #include <hashtable.h>
26 #include <list.h>
27 #include <xalloc.h>
28 #include "modpost.h"
29 #include "../../include/linux/license.h"
30
31 static bool module_enabled;
32 /* Are we using CONFIG_MODVERSIONS? */
33 static bool modversions;
34 /* Is CONFIG_MODULE_SRCVERSION_ALL set? */
35 static bool all_versions;
36 /* If we are modposting external module set to 1 */
37 static bool external_module;
38 /* Only warn about unresolved symbols */
39 static bool warn_unresolved;
40
41 static int sec_mismatch_count;
42 static bool sec_mismatch_warn_only = true;
43 /* Trim EXPORT_SYMBOLs that are unused by in-tree modules */
44 static bool trim_unused_exports;
45
46 /* ignore missing files */
47 static bool ignore_missing_files;
48 /* If set to 1, only warn (instead of error) about missing ns imports */
49 static bool allow_missing_ns_imports;
50
51 static bool error_occurred;
52
53 static bool extra_warn;
54
55 bool target_is_big_endian;
56 bool host_is_big_endian;
57
58 /*
59 * Cut off the warnings when there are too many. This typically occurs when
60 * vmlinux is missing. ('make modules' without building vmlinux.)
61 */
62 #define MAX_UNRESOLVED_REPORTS 10
63 static unsigned int nr_unresolved;
64
65 /* In kernel, this size is defined in linux/module.h;
66 * here we use Elf_Addr instead of long for covering cross-compile
67 */
68
69 #define MODULE_NAME_LEN (64 - sizeof(Elf_Addr))
70
71 void modpost_log(bool is_error, const char *fmt, ...)
72 {
73 va_list arglist;
74
75 if (is_error) {
76 fprintf(stderr, "ERROR: ");
77 error_occurred = true;
78 } else {
79 fprintf(stderr, "WARNING: ");
80 }
81
82 fprintf(stderr, "modpost: ");
83
84 va_start(arglist, fmt);
85 vfprintf(stderr, fmt, arglist);
86 va_end(arglist);
87 }
88
89 static inline bool strends(const char *str, const char *postfix)
90 {
91 if (strlen(str) < strlen(postfix))
92 return false;
93
94 return strcmp(str + strlen(str) - strlen(postfix), postfix) == 0;
95 }
96
97 char *read_text_file(const char *filename)
98 {
99 struct stat st;
100 size_t nbytes;
101 int fd;
102 char *buf;
103
104 fd = open(filename, O_RDONLY);
105 if (fd < 0) {
106 perror(filename);
107 exit(1);
108 }
109
110 if (fstat(fd, &st) < 0) {
111 perror(filename);
112 exit(1);
113 }
114
115 buf = xmalloc(st.st_size + 1);
116
117 nbytes = st.st_size;
118
119 while (nbytes) {
120 ssize_t bytes_read;
121
122 bytes_read = read(fd, buf, nbytes);
123 if (bytes_read < 0) {
124 perror(filename);
125 exit(1);
126 }
127
128 nbytes -= bytes_read;
129 }
130 buf[st.st_size] = '\0';
131
132 close(fd);
133
134 return buf;
135 }
136
137 char *get_line(char **stringp)
138 {
139 char *orig = *stringp, *next;
140
141 /* do not return the unwanted extra line at EOF */
142 if (!orig || *orig == '\0')
143 return NULL;
144
145 /* don't use strsep here, it is not available everywhere */
146 next = strchr(orig, '\n');
147 if (next)
148 *next++ = '\0';
149
150 *stringp = next;
151
152 return orig;
153 }
154
155 /* A list of all modules we processed */
156 LIST_HEAD(modules);
157
158 static struct module *find_module(const char *modname)
159 {
160 struct module *mod;
161
162 list_for_each_entry(mod, &modules, list) {
163 if (strcmp(mod->name, modname) == 0)
164 return mod;
165 }
166 return NULL;
167 }
168
169 static struct module *new_module(const char *name, size_t namelen)
170 {
171 struct module *mod;
172
173 mod = xmalloc(sizeof(*mod) + namelen + 1);
174 memset(mod, 0, sizeof(*mod));
175
176 INIT_LIST_HEAD(&mod->exported_symbols);
177 INIT_LIST_HEAD(&mod->unresolved_symbols);
178 INIT_LIST_HEAD(&mod->missing_namespaces);
179 INIT_LIST_HEAD(&mod->imported_namespaces);
180 INIT_LIST_HEAD(&mod->aliases);
181
182 memcpy(mod->name, name, namelen);
183 mod->name[namelen] = '\0';
184 mod->is_vmlinux = (strcmp(mod->name, "vmlinux") == 0);
185
186 /*
187 * Set mod->is_gpl_compatible to true by default. If MODULE_LICENSE()
188 * is missing, do not check the use for EXPORT_SYMBOL_GPL() becasue
189 * modpost will exit wiht error anyway.
190 */
191 mod->is_gpl_compatible = true;
192
193 list_add_tail(&mod->list, &modules);
194
195 return mod;
196 }
197
198 struct symbol {
199 struct hlist_node hnode;/* link to hash table */
200 struct list_head list; /* link to module::exported_symbols or module::unresolved_symbols */
201 struct module *module;
202 char *namespace;
203 unsigned int crc;
204 bool crc_valid;
205 bool weak;
206 bool is_func;
207 bool is_gpl_only; /* exported by EXPORT_SYMBOL_GPL */
208 bool used; /* there exists a user of this symbol */
209 char name[];
210 };
211
212 static HASHTABLE_DEFINE(symbol_hashtable, 1U << 10);
213
214 /**
215 * Allocate a new symbols for use in the hash of exported symbols or
216 * the list of unresolved symbols per module
217 **/
218 static struct symbol *alloc_symbol(const char *name)
219 {
220 struct symbol *s = xmalloc(sizeof(*s) + strlen(name) + 1);
221
222 memset(s, 0, sizeof(*s));
223 strcpy(s->name, name);
224
225 return s;
226 }
227
228 /* For the hash of exported symbols */
229 static void hash_add_symbol(struct symbol *sym)
230 {
231 hash_add(symbol_hashtable, &sym->hnode, hash_str(sym->name));
232 }
233
234 static void sym_add_unresolved(const char *name, struct module *mod, bool weak)
235 {
236 struct symbol *sym;
237
238 sym = alloc_symbol(name);
239 sym->weak = weak;
240
241 list_add_tail(&sym->list, &mod->unresolved_symbols);
242 }
243
244 static struct symbol *sym_find_with_module(const char *name, struct module *mod)
245 {
246 struct symbol *s;
247
248 /* For our purposes, .foo matches foo. PPC64 needs this. */
249 if (name[0] == '.')
250 name++;
251
252 hash_for_each_possible(symbol_hashtable, s, hnode, hash_str(name)) {
253 if (strcmp(s->name, name) == 0 && (!mod || s->module == mod))
254 return s;
255 }
256 return NULL;
257 }
258
259 static struct symbol *find_symbol(const char *name)
260 {
261 return sym_find_with_module(name, NULL);
262 }
263
264 struct namespace_list {
265 struct list_head list;
266 char namespace[];
267 };
268
269 static bool contains_namespace(struct list_head *head, const char *namespace)
270 {
271 struct namespace_list *list;
272
273 /*
274 * The default namespace is null string "", which is always implicitly
275 * contained.
276 */
277 if (!namespace[0])
278 return true;
279
280 list_for_each_entry(list, head, list) {
281 if (!strcmp(list->namespace, namespace))
282 return true;
283 }
284
285 return false;
286 }
287
288 static void add_namespace(struct list_head *head, const char *namespace)
289 {
290 struct namespace_list *ns_entry;
291
292 if (!contains_namespace(head, namespace)) {
293 ns_entry = xmalloc(sizeof(*ns_entry) + strlen(namespace) + 1);
294 strcpy(ns_entry->namespace, namespace);
295 list_add_tail(&ns_entry->list, head);
296 }
297 }
298
299 static void *sym_get_data_by_offset(const struct elf_info *info,
300 unsigned int secindex, unsigned long offset)
301 {
302 Elf_Shdr *sechdr = &info->sechdrs[secindex];
303
304 return (void *)info->hdr + sechdr->sh_offset + offset;
305 }
306
307 void *sym_get_data(const struct elf_info *info, const Elf_Sym *sym)
308 {
309 return sym_get_data_by_offset(info, get_secindex(info, sym),
310 sym->st_value);
311 }
312
313 static const char *sech_name(const struct elf_info *info, Elf_Shdr *sechdr)
314 {
315 return sym_get_data_by_offset(info, info->secindex_strings,
316 sechdr->sh_name);
317 }
318
319 static const char *sec_name(const struct elf_info *info, unsigned int secindex)
320 {
321 /*
322 * If sym->st_shndx is a special section index, there is no
323 * corresponding section header.
324 * Return "" if the index is out of range of info->sechdrs[] array.
325 */
326 if (secindex >= info->num_sections)
327 return "";
328
329 return sech_name(info, &info->sechdrs[secindex]);
330 }
331
332 static struct symbol *sym_add_exported(const char *name, struct module *mod,
333 bool gpl_only, const char *namespace)
334 {
335 struct symbol *s = find_symbol(name);
336
337 if (s && (!external_module || s->module->is_vmlinux || s->module == mod)) {
338 error("%s: '%s' exported twice. Previous export was in %s%s\n",
339 mod->name, name, s->module->name,
340 s->module->is_vmlinux ? "" : ".ko");
341 }
342
343 s = alloc_symbol(name);
344 s->module = mod;
345 s->is_gpl_only = gpl_only;
346 s->namespace = xstrdup(namespace);
347 list_add_tail(&s->list, &mod->exported_symbols);
348 hash_add_symbol(s);
349
350 return s;
351 }
352
353 static void sym_set_crc(struct symbol *sym, unsigned int crc)
354 {
355 sym->crc = crc;
356 sym->crc_valid = true;
357 }
358
359 static void *grab_file(const char *filename, size_t *size)
360 {
361 struct stat st;
362 void *map = MAP_FAILED;
363 int fd;
364
365 fd = open(filename, O_RDONLY);
366 if (fd < 0)
367 return NULL;
368 if (fstat(fd, &st))
369 goto failed;
370
371 *size = st.st_size;
372 map = mmap(NULL, *size, PROT_READ|PROT_WRITE, MAP_PRIVATE, fd, 0);
373
374 failed:
375 close(fd);
376 if (map == MAP_FAILED)
377 return NULL;
378 return map;
379 }
380
381 static void release_file(void *file, size_t size)
382 {
383 munmap(file, size);
384 }
385
386 static int parse_elf(struct elf_info *info, const char *filename)
387 {
388 unsigned int i;
389 Elf_Ehdr *hdr;
390 Elf_Shdr *sechdrs;
391 Elf_Sym *sym;
392 const char *secstrings;
393 unsigned int symtab_idx = ~0U, symtab_shndx_idx = ~0U;
394
395 hdr = grab_file(filename, &info->size);
396 if (!hdr) {
397 if (ignore_missing_files) {
398 fprintf(stderr, "%s: %s (ignored)\n", filename,
399 strerror(errno));
400 return 0;
401 }
402 perror(filename);
403 exit(1);
404 }
405 info->hdr = hdr;
406 if (info->size < sizeof(*hdr)) {
407 /* file too small, assume this is an empty .o file */
408 return 0;
409 }
410 /* Is this a valid ELF file? */
411 if ((hdr->e_ident[EI_MAG0] != ELFMAG0) ||
412 (hdr->e_ident[EI_MAG1] != ELFMAG1) ||
413 (hdr->e_ident[EI_MAG2] != ELFMAG2) ||
414 (hdr->e_ident[EI_MAG3] != ELFMAG3)) {
415 /* Not an ELF file - silently ignore it */
416 return 0;
417 }
418
419 switch (hdr->e_ident[EI_DATA]) {
420 case ELFDATA2LSB:
421 target_is_big_endian = false;
422 break;
423 case ELFDATA2MSB:
424 target_is_big_endian = true;
425 break;
426 default:
427 fatal("target endian is unknown\n");
428 }
429
430 /* Fix endianness in ELF header */
431 hdr->e_type = TO_NATIVE(hdr->e_type);
432 hdr->e_machine = TO_NATIVE(hdr->e_machine);
433 hdr->e_version = TO_NATIVE(hdr->e_version);
434 hdr->e_entry = TO_NATIVE(hdr->e_entry);
435 hdr->e_phoff = TO_NATIVE(hdr->e_phoff);
436 hdr->e_shoff = TO_NATIVE(hdr->e_shoff);
437 hdr->e_flags = TO_NATIVE(hdr->e_flags);
438 hdr->e_ehsize = TO_NATIVE(hdr->e_ehsize);
439 hdr->e_phentsize = TO_NATIVE(hdr->e_phentsize);
440 hdr->e_phnum = TO_NATIVE(hdr->e_phnum);
441 hdr->e_shentsize = TO_NATIVE(hdr->e_shentsize);
442 hdr->e_shnum = TO_NATIVE(hdr->e_shnum);
443 hdr->e_shstrndx = TO_NATIVE(hdr->e_shstrndx);
444 sechdrs = (void *)hdr + hdr->e_shoff;
445 info->sechdrs = sechdrs;
446
447 /* modpost only works for relocatable objects */
448 if (hdr->e_type != ET_REL)
449 fatal("%s: not relocatable object.", filename);
450
451 /* Check if file offset is correct */
452 if (hdr->e_shoff > info->size)
453 fatal("section header offset=%lu in file '%s' is bigger than filesize=%zu\n",
454 (unsigned long)hdr->e_shoff, filename, info->size);
455
456 if (hdr->e_shnum == SHN_UNDEF) {
457 /*
458 * There are more than 64k sections,
459 * read count from .sh_size.
460 */
461 info->num_sections = TO_NATIVE(sechdrs[0].sh_size);
462 }
463 else {
464 info->num_sections = hdr->e_shnum;
465 }
466 if (hdr->e_shstrndx == SHN_XINDEX) {
467 info->secindex_strings = TO_NATIVE(sechdrs[0].sh_link);
468 }
469 else {
470 info->secindex_strings = hdr->e_shstrndx;
471 }
472
473 /* Fix endianness in section headers */
474 for (i = 0; i < info->num_sections; i++) {
475 sechdrs[i].sh_name = TO_NATIVE(sechdrs[i].sh_name);
476 sechdrs[i].sh_type = TO_NATIVE(sechdrs[i].sh_type);
477 sechdrs[i].sh_flags = TO_NATIVE(sechdrs[i].sh_flags);
478 sechdrs[i].sh_addr = TO_NATIVE(sechdrs[i].sh_addr);
479 sechdrs[i].sh_offset = TO_NATIVE(sechdrs[i].sh_offset);
480 sechdrs[i].sh_size = TO_NATIVE(sechdrs[i].sh_size);
481 sechdrs[i].sh_link = TO_NATIVE(sechdrs[i].sh_link);
482 sechdrs[i].sh_info = TO_NATIVE(sechdrs[i].sh_info);
483 sechdrs[i].sh_addralign = TO_NATIVE(sechdrs[i].sh_addralign);
484 sechdrs[i].sh_entsize = TO_NATIVE(sechdrs[i].sh_entsize);
485 }
486 /* Find symbol table. */
487 secstrings = (void *)hdr + sechdrs[info->secindex_strings].sh_offset;
488 for (i = 1; i < info->num_sections; i++) {
489 const char *secname;
490 int nobits = sechdrs[i].sh_type == SHT_NOBITS;
491
492 if (!nobits && sechdrs[i].sh_offset > info->size)
493 fatal("%s is truncated. sechdrs[i].sh_offset=%lu > sizeof(*hrd)=%zu\n",
494 filename, (unsigned long)sechdrs[i].sh_offset,
495 sizeof(*hdr));
496
497 secname = secstrings + sechdrs[i].sh_name;
498 if (strcmp(secname, ".modinfo") == 0) {
499 if (nobits)
500 fatal("%s has NOBITS .modinfo\n", filename);
501 info->modinfo = (void *)hdr + sechdrs[i].sh_offset;
502 info->modinfo_len = sechdrs[i].sh_size;
503 } else if (!strcmp(secname, ".export_symbol")) {
504 info->export_symbol_secndx = i;
505 }
506
507 if (sechdrs[i].sh_type == SHT_SYMTAB) {
508 unsigned int sh_link_idx;
509 symtab_idx = i;
510 info->symtab_start = (void *)hdr +
511 sechdrs[i].sh_offset;
512 info->symtab_stop = (void *)hdr +
513 sechdrs[i].sh_offset + sechdrs[i].sh_size;
514 sh_link_idx = sechdrs[i].sh_link;
515 info->strtab = (void *)hdr +
516 sechdrs[sh_link_idx].sh_offset;
517 }
518
519 /* 32bit section no. table? ("more than 64k sections") */
520 if (sechdrs[i].sh_type == SHT_SYMTAB_SHNDX) {
521 symtab_shndx_idx = i;
522 info->symtab_shndx_start = (void *)hdr +
523 sechdrs[i].sh_offset;
524 info->symtab_shndx_stop = (void *)hdr +
525 sechdrs[i].sh_offset + sechdrs[i].sh_size;
526 }
527 }
528 if (!info->symtab_start)
529 fatal("%s has no symtab?\n", filename);
530
531 /* Fix endianness in symbols */
532 for (sym = info->symtab_start; sym < info->symtab_stop; sym++) {
533 sym->st_shndx = TO_NATIVE(sym->st_shndx);
534 sym->st_name = TO_NATIVE(sym->st_name);
535 sym->st_value = TO_NATIVE(sym->st_value);
536 sym->st_size = TO_NATIVE(sym->st_size);
537 }
538
539 if (symtab_shndx_idx != ~0U) {
540 Elf32_Word *p;
541 if (symtab_idx != sechdrs[symtab_shndx_idx].sh_link)
542 fatal("%s: SYMTAB_SHNDX has bad sh_link: %u!=%u\n",
543 filename, sechdrs[symtab_shndx_idx].sh_link,
544 symtab_idx);
545 /* Fix endianness */
546 for (p = info->symtab_shndx_start; p < info->symtab_shndx_stop;
547 p++)
548 *p = TO_NATIVE(*p);
549 }
550
551 symsearch_init(info);
552
553 return 1;
554 }
555
556 static void parse_elf_finish(struct elf_info *info)
557 {
558 symsearch_finish(info);
559 release_file(info->hdr, info->size);
560 }
561
562 static 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, "__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 (strstarts(symname, "_restgpr_") ||
573 strstarts(symname, "_savegpr_") ||
574 strstarts(symname, "_rest32gpr_") ||
575 strstarts(symname, "_save32gpr_") ||
576 strstarts(symname, "_restvr_") ||
577 strstarts(symname, "_savevr_"))
578 return 1;
579 if (info->hdr->e_machine == EM_PPC64)
580 /* Special register function linked on all modules during final link of .ko */
581 if (strstarts(symname, "_restgpr0_") ||
582 strstarts(symname, "_savegpr0_") ||
583 strstarts(symname, "_restvr_") ||
584 strstarts(symname, "_savevr_") ||
585 strcmp(symname, ".TOC.") == 0)
586 return 1;
587 /* Do not ignore this symbol */
588 return 0;
589 }
590
591 static void handle_symbol(struct module *mod, struct elf_info *info,
592 const Elf_Sym *sym, const char *symname)
593 {
594 switch (sym->st_shndx) {
595 case SHN_COMMON:
596 if (strstarts(symname, "__gnu_lto_")) {
597 /* Should warn here, but modpost runs before the linker */
598 } else
599 warn("\"%s\" [%s] is COMMON symbol\n", symname, mod->name);
600 break;
601 case SHN_UNDEF:
602 /* undefined symbol */
603 if (ELF_ST_BIND(sym->st_info) != STB_GLOBAL &&
604 ELF_ST_BIND(sym->st_info) != STB_WEAK)
605 break;
606 if (ignore_undef_symbol(info, symname))
607 break;
608 if (info->hdr->e_machine == EM_SPARC ||
609 info->hdr->e_machine == EM_SPARCV9) {
610 /* Ignore register directives. */
611 if (ELF_ST_TYPE(sym->st_info) == STT_SPARC_REGISTER)
612 break;
613 if (symname[0] == '.') {
614 char *munged = xstrdup(symname);
615 munged[0] = '_';
616 munged[1] = toupper(munged[1]);
617 symname = munged;
618 }
619 }
620
621 sym_add_unresolved(symname, mod,
622 ELF_ST_BIND(sym->st_info) == STB_WEAK);
623 break;
624 default:
625 if (strcmp(symname, "init_module") == 0)
626 mod->has_init = true;
627 if (strcmp(symname, "cleanup_module") == 0)
628 mod->has_cleanup = true;
629 break;
630 }
631 }
632
633 /**
634 * Parse tag=value strings from .modinfo section
635 **/
636 static char *next_string(char *string, unsigned long *secsize)
637 {
638 /* Skip non-zero chars */
639 while (string[0]) {
640 string++;
641 if ((*secsize)-- <= 1)
642 return NULL;
643 }
644
645 /* Skip any zero padding. */
646 while (!string[0]) {
647 string++;
648 if ((*secsize)-- <= 1)
649 return NULL;
650 }
651 return string;
652 }
653
654 static char *get_next_modinfo(struct elf_info *info, const char *tag,
655 char *prev)
656 {
657 char *p;
658 unsigned int taglen = strlen(tag);
659 char *modinfo = info->modinfo;
660 unsigned long size = info->modinfo_len;
661
662 if (prev) {
663 size -= prev - modinfo;
664 modinfo = next_string(prev, &size);
665 }
666
667 for (p = modinfo; p; p = next_string(p, &size)) {
668 if (strncmp(p, tag, taglen) == 0 && p[taglen] == '=')
669 return p + taglen + 1;
670 }
671 return NULL;
672 }
673
674 static char *get_modinfo(struct elf_info *info, const char *tag)
675
676 {
677 return get_next_modinfo(info, tag, NULL);
678 }
679
680 static const char *sym_name(struct elf_info *elf, Elf_Sym *sym)
681 {
682 return sym ? elf->strtab + sym->st_name : "";
683 }
684
685 /*
686 * Check whether the 'string' argument matches one of the 'patterns',
687 * an array of shell wildcard patterns (glob).
688 *
689 * Return true is there is a match.
690 */
691 static bool match(const char *string, const char *const patterns[])
692 {
693 const char *pattern;
694
695 while ((pattern = *patterns++)) {
696 if (!fnmatch(pattern, string, 0))
697 return true;
698 }
699
700 return false;
701 }
702
703 /* useful to pass patterns to match() directly */
704 #define PATTERNS(...) \
705 ({ \
706 static const char *const patterns[] = {__VA_ARGS__, NULL}; \
707 patterns; \
708 })
709
710 /* sections that we do not want to do full section mismatch check on */
711 static const char *const section_white_list[] =
712 {
713 ".comment*",
714 ".debug*",
715 ".zdebug*", /* Compressed debug sections. */
716 ".GCC.command.line", /* record-gcc-switches */
717 ".mdebug*", /* alpha, score, mips etc. */
718 ".pdr", /* alpha, score, mips etc. */
719 ".stab*",
720 ".note*",
721 ".got*",
722 ".toc*",
723 ".xt.prop", /* xtensa */
724 ".xt.lit", /* xtensa */
725 ".arcextmap*", /* arc */
726 ".gnu.linkonce.arcext*", /* arc : modules */
727 ".cmem*", /* EZchip */
728 ".fmt_slot*", /* EZchip */
729 ".gnu.lto*",
730 ".discard.*",
731 ".llvm.call-graph-profile", /* call graph */
732 NULL
733 };
734
735 /*
736 * This is used to find sections missing the SHF_ALLOC flag.
737 * The cause of this is often a section specified in assembler
738 * without "ax" / "aw".
739 */
740 static void check_section(const char *modname, struct elf_info *elf,
741 Elf_Shdr *sechdr)
742 {
743 const char *sec = sech_name(elf, sechdr);
744
745 if (sechdr->sh_type == SHT_PROGBITS &&
746 !(sechdr->sh_flags & SHF_ALLOC) &&
747 !match(sec, section_white_list)) {
748 warn("%s (%s): unexpected non-allocatable section.\n"
749 "Did you forget to use \"ax\"/\"aw\" in a .S file?\n"
750 "Note that for example <linux/init.h> contains\n"
751 "section definitions for use in .S files.\n\n",
752 modname, sec);
753 }
754 }
755
756
757
758 #define ALL_INIT_DATA_SECTIONS \
759 ".init.setup", ".init.rodata", ".init.data"
760
761 #define ALL_PCI_INIT_SECTIONS \
762 ".pci_fixup_early", ".pci_fixup_header", ".pci_fixup_final", \
763 ".pci_fixup_enable", ".pci_fixup_resume", \
764 ".pci_fixup_resume_early", ".pci_fixup_suspend"
765
766 #define ALL_INIT_SECTIONS ".init.*"
767 #define ALL_EXIT_SECTIONS ".exit.*"
768
769 #define DATA_SECTIONS ".data", ".data.rel"
770 #define TEXT_SECTIONS ".text", ".text.*", ".sched.text", \
771 ".kprobes.text", ".cpuidle.text", ".noinstr.text", \
772 ".ltext", ".ltext.*"
773 #define OTHER_TEXT_SECTIONS ".ref.text", ".head.text", ".spinlock.text", \
774 ".fixup", ".entry.text", ".exception.text", \
775 ".coldtext", ".softirqentry.text", ".irqentry.text"
776
777 #define ALL_TEXT_SECTIONS ".init.text", ".exit.text", \
778 TEXT_SECTIONS, OTHER_TEXT_SECTIONS
779
780 enum mismatch {
781 TEXTDATA_TO_ANY_INIT_EXIT,
782 XXXINIT_TO_SOME_INIT,
783 ANY_INIT_TO_ANY_EXIT,
784 ANY_EXIT_TO_ANY_INIT,
785 EXTABLE_TO_NON_TEXT,
786 };
787
788 /**
789 * Describe how to match sections on different criteria:
790 *
791 * @fromsec: Array of sections to be matched.
792 *
793 * @bad_tosec: Relocations applied to a section in @fromsec to a section in
794 * this array is forbidden (black-list). Can be empty.
795 *
796 * @good_tosec: Relocations applied to a section in @fromsec must be
797 * targeting sections in this array (white-list). Can be empty.
798 *
799 * @mismatch: Type of mismatch.
800 */
801 struct sectioncheck {
802 const char *fromsec[20];
803 const char *bad_tosec[20];
804 const char *good_tosec[20];
805 enum mismatch mismatch;
806 };
807
808 static const struct sectioncheck sectioncheck[] = {
809 /* Do not reference init/exit code/data from
810 * normal code and data
811 */
812 {
813 .fromsec = { TEXT_SECTIONS, DATA_SECTIONS, NULL },
814 .bad_tosec = { ALL_INIT_SECTIONS, ALL_EXIT_SECTIONS, NULL },
815 .mismatch = TEXTDATA_TO_ANY_INIT_EXIT,
816 },
817 /* Do not use exit code/data from init code */
818 {
819 .fromsec = { ALL_INIT_SECTIONS, NULL },
820 .bad_tosec = { ALL_EXIT_SECTIONS, NULL },
821 .mismatch = ANY_INIT_TO_ANY_EXIT,
822 },
823 /* Do not use init code/data from exit code */
824 {
825 .fromsec = { ALL_EXIT_SECTIONS, NULL },
826 .bad_tosec = { ALL_INIT_SECTIONS, NULL },
827 .mismatch = ANY_EXIT_TO_ANY_INIT,
828 },
829 {
830 .fromsec = { ALL_PCI_INIT_SECTIONS, NULL },
831 .bad_tosec = { ALL_INIT_SECTIONS, NULL },
832 .mismatch = ANY_INIT_TO_ANY_EXIT,
833 },
834 {
835 .fromsec = { "__ex_table", NULL },
836 /* If you're adding any new black-listed sections in here, consider
837 * adding a special 'printer' for them in scripts/check_extable.
838 */
839 .bad_tosec = { ".altinstr_replacement", NULL },
840 .good_tosec = {ALL_TEXT_SECTIONS , NULL},
841 .mismatch = EXTABLE_TO_NON_TEXT,
842 }
843 };
844
845 static const struct sectioncheck *section_mismatch(
846 const char *fromsec, const char *tosec)
847 {
848 int i;
849
850 /*
851 * The target section could be the SHT_NUL section when we're
852 * handling relocations to un-resolved symbols, trying to match it
853 * doesn't make much sense and causes build failures on parisc
854 * architectures.
855 */
856 if (*tosec == '\0')
857 return NULL;
858
859 for (i = 0; i < ARRAY_SIZE(sectioncheck); i++) {
860 const struct sectioncheck *check = &sectioncheck[i];
861
862 if (match(fromsec, check->fromsec)) {
863 if (check->bad_tosec[0] && match(tosec, check->bad_tosec))
864 return check;
865 if (check->good_tosec[0] && !match(tosec, check->good_tosec))
866 return check;
867 }
868 }
869 return NULL;
870 }
871
872 /**
873 * Whitelist to allow certain references to pass with no warning.
874 *
875 * Pattern 1:
876 * If a module parameter is declared __initdata and permissions=0
877 * then this is legal despite the warning generated.
878 * We cannot see value of permissions here, so just ignore
879 * this pattern.
880 * The pattern is identified by:
881 * tosec = .init.data
882 * fromsec = .data*
883 * atsym =__param*
884 *
885 * Pattern 1a:
886 * module_param_call() ops can refer to __init set function if permissions=0
887 * The pattern is identified by:
888 * tosec = .init.text
889 * fromsec = .data*
890 * atsym = __param_ops_*
891 *
892 * Pattern 3:
893 * Whitelist all references from .head.text to any init section
894 *
895 * Pattern 4:
896 * Some symbols belong to init section but still it is ok to reference
897 * these from non-init sections as these symbols don't have any memory
898 * allocated for them and symbol address and value are same. So even
899 * if init section is freed, its ok to reference those symbols.
900 * For ex. symbols marking the init section boundaries.
901 * This pattern is identified by
902 * refsymname = __init_begin, _sinittext, _einittext
903 *
904 * Pattern 5:
905 * GCC may optimize static inlines when fed constant arg(s) resulting
906 * in functions like cpumask_empty() -- generating an associated symbol
907 * cpumask_empty.constprop.3 that appears in the audit. If the const that
908 * is passed in comes from __init, like say nmi_ipi_mask, we get a
909 * meaningless section warning. May need to add isra symbols too...
910 * This pattern is identified by
911 * tosec = init section
912 * fromsec = text section
913 * refsymname = *.constprop.*
914 *
915 **/
916 static int secref_whitelist(const char *fromsec, const char *fromsym,
917 const char *tosec, const char *tosym)
918 {
919 /* Check for pattern 1 */
920 if (match(tosec, PATTERNS(ALL_INIT_DATA_SECTIONS)) &&
921 match(fromsec, PATTERNS(DATA_SECTIONS)) &&
922 strstarts(fromsym, "__param"))
923 return 0;
924
925 /* Check for pattern 1a */
926 if (strcmp(tosec, ".init.text") == 0 &&
927 match(fromsec, PATTERNS(DATA_SECTIONS)) &&
928 strstarts(fromsym, "__param_ops_"))
929 return 0;
930
931 /* symbols in data sections that may refer to any init/exit sections */
932 if (match(fromsec, PATTERNS(DATA_SECTIONS)) &&
933 match(tosec, PATTERNS(ALL_INIT_SECTIONS, ALL_EXIT_SECTIONS)) &&
934 match(fromsym, PATTERNS("*_ops", "*_probe", "*_console")))
935 return 0;
936
937 /* Check for pattern 3 */
938 if (strstarts(fromsec, ".head.text") &&
939 match(tosec, PATTERNS(ALL_INIT_SECTIONS)))
940 return 0;
941
942 /* Check for pattern 4 */
943 if (match(tosym, PATTERNS("__init_begin", "_sinittext", "_einittext")))
944 return 0;
945
946 /* Check for pattern 5 */
947 if (match(fromsec, PATTERNS(ALL_TEXT_SECTIONS)) &&
948 match(tosec, PATTERNS(ALL_INIT_SECTIONS)) &&
949 match(fromsym, PATTERNS("*.constprop.*")))
950 return 0;
951
952 return 1;
953 }
954
955 static Elf_Sym *find_fromsym(struct elf_info *elf, Elf_Addr addr,
956 unsigned int secndx)
957 {
958 return symsearch_find_nearest(elf, addr, secndx, false, ~0);
959 }
960
961 static Elf_Sym *find_tosym(struct elf_info *elf, Elf_Addr addr, Elf_Sym *sym)
962 {
963 Elf_Sym *new_sym;
964
965 /* If the supplied symbol has a valid name, return it */
966 if (is_valid_name(elf, sym))
967 return sym;
968
969 /*
970 * Strive to find a better symbol name, but the resulting name may not
971 * match the symbol referenced in the original code.
972 */
973 new_sym = symsearch_find_nearest(elf, addr, get_secindex(elf, sym),
974 true, 20);
975 return new_sym ? new_sym : sym;
976 }
977
978 static bool is_executable_section(struct elf_info *elf, unsigned int secndx)
979 {
980 if (secndx >= elf->num_sections)
981 return false;
982
983 return (elf->sechdrs[secndx].sh_flags & SHF_EXECINSTR) != 0;
984 }
985
986 static void default_mismatch_handler(const char *modname, struct elf_info *elf,
987 const struct sectioncheck* const mismatch,
988 Elf_Sym *tsym,
989 unsigned int fsecndx, const char *fromsec, Elf_Addr faddr,
990 const char *tosec, Elf_Addr taddr)
991 {
992 Elf_Sym *from;
993 const char *tosym;
994 const char *fromsym;
995 char taddr_str[16];
996
997 from = find_fromsym(elf, faddr, fsecndx);
998 fromsym = sym_name(elf, from);
999
1000 tsym = find_tosym(elf, taddr, tsym);
1001 tosym = sym_name(elf, tsym);
1002
1003 /* check whitelist - we may ignore it */
1004 if (!secref_whitelist(fromsec, fromsym, tosec, tosym))
1005 return;
1006
1007 sec_mismatch_count++;
1008
1009 if (!tosym[0])
1010 snprintf(taddr_str, sizeof(taddr_str), "0x%x", (unsigned int)taddr);
1011
1012 /*
1013 * The format for the reference source: <symbol_name>+<offset> or <address>
1014 * The format for the reference destination: <symbol_name> or <address>
1015 */
1016 warn("%s: section mismatch in reference: %s%s0x%x (section: %s) -> %s (section: %s)\n",
1017 modname, fromsym, fromsym[0] ? "+" : "",
1018 (unsigned int)(faddr - (fromsym[0] ? from->st_value : 0)),
1019 fromsec, tosym[0] ? tosym : taddr_str, tosec);
1020
1021 if (mismatch->mismatch == EXTABLE_TO_NON_TEXT) {
1022 if (match(tosec, mismatch->bad_tosec))
1023 fatal("The relocation at %s+0x%lx references\n"
1024 "section \"%s\" which is black-listed.\n"
1025 "Something is seriously wrong and should be fixed.\n"
1026 "You might get more information about where this is\n"
1027 "coming from by using scripts/check_extable.sh %s\n",
1028 fromsec, (long)faddr, tosec, modname);
1029 else if (is_executable_section(elf, get_secindex(elf, tsym)))
1030 warn("The relocation at %s+0x%lx references\n"
1031 "section \"%s\" which is not in the list of\n"
1032 "authorized sections. If you're adding a new section\n"
1033 "and/or if this reference is valid, add \"%s\" to the\n"
1034 "list of authorized sections to jump to on fault.\n"
1035 "This can be achieved by adding \"%s\" to\n"
1036 "OTHER_TEXT_SECTIONS in scripts/mod/modpost.c.\n",
1037 fromsec, (long)faddr, tosec, tosec, tosec);
1038 else
1039 error("%s+0x%lx references non-executable section '%s'\n",
1040 fromsec, (long)faddr, tosec);
1041 }
1042 }
1043
1044 static void check_export_symbol(struct module *mod, struct elf_info *elf,
1045 Elf_Addr faddr, const char *secname,
1046 Elf_Sym *sym)
1047 {
1048 static const char *prefix = "__export_symbol_";
1049 const char *label_name, *name, *data;
1050 Elf_Sym *label;
1051 struct symbol *s;
1052 bool is_gpl;
1053
1054 label = find_fromsym(elf, faddr, elf->export_symbol_secndx);
1055 label_name = sym_name(elf, label);
1056
1057 if (!strstarts(label_name, prefix)) {
1058 error("%s: .export_symbol section contains strange symbol '%s'\n",
1059 mod->name, label_name);
1060 return;
1061 }
1062
1063 if (ELF_ST_BIND(sym->st_info) != STB_GLOBAL &&
1064 ELF_ST_BIND(sym->st_info) != STB_WEAK) {
1065 error("%s: local symbol '%s' was exported\n", mod->name,
1066 label_name + strlen(prefix));
1067 return;
1068 }
1069
1070 name = sym_name(elf, sym);
1071 if (strcmp(label_name + strlen(prefix), name)) {
1072 error("%s: .export_symbol section references '%s', but it does not seem to be an export symbol\n",
1073 mod->name, name);
1074 return;
1075 }
1076
1077 data = sym_get_data(elf, label); /* license */
1078 if (!strcmp(data, "GPL")) {
1079 is_gpl = true;
1080 } else if (!strcmp(data, "")) {
1081 is_gpl = false;
1082 } else {
1083 error("%s: unknown license '%s' was specified for '%s'\n",
1084 mod->name, data, name);
1085 return;
1086 }
1087
1088 data += strlen(data) + 1; /* namespace */
1089 s = sym_add_exported(name, mod, is_gpl, data);
1090
1091 /*
1092 * We need to be aware whether we are exporting a function or
1093 * a data on some architectures.
1094 */
1095 s->is_func = (ELF_ST_TYPE(sym->st_info) == STT_FUNC);
1096
1097 /*
1098 * For parisc64, symbols prefixed $$ from the library have the symbol type
1099 * STT_LOPROC. They should be handled as functions too.
1100 */
1101 if (elf->hdr->e_ident[EI_CLASS] == ELFCLASS64 &&
1102 elf->hdr->e_machine == EM_PARISC &&
1103 ELF_ST_TYPE(sym->st_info) == STT_LOPROC)
1104 s->is_func = true;
1105
1106 if (match(secname, PATTERNS(ALL_INIT_SECTIONS)))
1107 warn("%s: %s: EXPORT_SYMBOL used for init symbol. Remove __init or EXPORT_SYMBOL.\n",
1108 mod->name, name);
1109 else if (match(secname, PATTERNS(ALL_EXIT_SECTIONS)))
1110 warn("%s: %s: EXPORT_SYMBOL used for exit symbol. Remove __exit or EXPORT_SYMBOL.\n",
1111 mod->name, name);
1112 }
1113
1114 static void check_section_mismatch(struct module *mod, struct elf_info *elf,
1115 Elf_Sym *sym,
1116 unsigned int fsecndx, const char *fromsec,
1117 Elf_Addr faddr, Elf_Addr taddr)
1118 {
1119 const char *tosec = sec_name(elf, get_secindex(elf, sym));
1120 const struct sectioncheck *mismatch;
1121
1122 if (module_enabled && elf->export_symbol_secndx == fsecndx) {
1123 check_export_symbol(mod, elf, faddr, tosec, sym);
1124 return;
1125 }
1126
1127 mismatch = section_mismatch(fromsec, tosec);
1128 if (!mismatch)
1129 return;
1130
1131 default_mismatch_handler(mod->name, elf, mismatch, sym,
1132 fsecndx, fromsec, faddr,
1133 tosec, taddr);
1134 }
1135
1136 static Elf_Addr addend_386_rel(uint32_t *location, unsigned int r_type)
1137 {
1138 switch (r_type) {
1139 case R_386_32:
1140 return TO_NATIVE(*location);
1141 case R_386_PC32:
1142 return TO_NATIVE(*location) + 4;
1143 }
1144
1145 return (Elf_Addr)(-1);
1146 }
1147
1148 static int32_t sign_extend32(int32_t value, int index)
1149 {
1150 uint8_t shift = 31 - index;
1151
1152 return (int32_t)(value << shift) >> shift;
1153 }
1154
1155 static Elf_Addr addend_arm_rel(void *loc, Elf_Sym *sym, unsigned int r_type)
1156 {
1157 uint32_t inst, upper, lower, sign, j1, j2;
1158 int32_t offset;
1159
1160 switch (r_type) {
1161 case R_ARM_ABS32:
1162 case R_ARM_REL32:
1163 inst = TO_NATIVE(*(uint32_t *)loc);
1164 return inst + sym->st_value;
1165 case R_ARM_MOVW_ABS_NC:
1166 case R_ARM_MOVT_ABS:
1167 inst = TO_NATIVE(*(uint32_t *)loc);
1168 offset = sign_extend32(((inst & 0xf0000) >> 4) | (inst & 0xfff),
1169 15);
1170 return offset + sym->st_value;
1171 case R_ARM_PC24:
1172 case R_ARM_CALL:
1173 case R_ARM_JUMP24:
1174 inst = TO_NATIVE(*(uint32_t *)loc);
1175 offset = sign_extend32((inst & 0x00ffffff) << 2, 25);
1176 return offset + sym->st_value + 8;
1177 case R_ARM_THM_MOVW_ABS_NC:
1178 case R_ARM_THM_MOVT_ABS:
1179 upper = TO_NATIVE(*(uint16_t *)loc);
1180 lower = TO_NATIVE(*((uint16_t *)loc + 1));
1181 offset = sign_extend32(((upper & 0x000f) << 12) |
1182 ((upper & 0x0400) << 1) |
1183 ((lower & 0x7000) >> 4) |
1184 (lower & 0x00ff),
1185 15);
1186 return offset + sym->st_value;
1187 case R_ARM_THM_JUMP19:
1188 /*
1189 * Encoding T3:
1190 * S = upper[10]
1191 * imm6 = upper[5:0]
1192 * J1 = lower[13]
1193 * J2 = lower[11]
1194 * imm11 = lower[10:0]
1195 * imm32 = SignExtend(S:J2:J1:imm6:imm11:'0')
1196 */
1197 upper = TO_NATIVE(*(uint16_t *)loc);
1198 lower = TO_NATIVE(*((uint16_t *)loc + 1));
1199
1200 sign = (upper >> 10) & 1;
1201 j1 = (lower >> 13) & 1;
1202 j2 = (lower >> 11) & 1;
1203 offset = sign_extend32((sign << 20) | (j2 << 19) | (j1 << 18) |
1204 ((upper & 0x03f) << 12) |
1205 ((lower & 0x07ff) << 1),
1206 20);
1207 return offset + sym->st_value + 4;
1208 case R_ARM_THM_PC22:
1209 case R_ARM_THM_JUMP24:
1210 /*
1211 * Encoding T4:
1212 * S = upper[10]
1213 * imm10 = upper[9:0]
1214 * J1 = lower[13]
1215 * J2 = lower[11]
1216 * imm11 = lower[10:0]
1217 * I1 = NOT(J1 XOR S)
1218 * I2 = NOT(J2 XOR S)
1219 * imm32 = SignExtend(S:I1:I2:imm10:imm11:'0')
1220 */
1221 upper = TO_NATIVE(*(uint16_t *)loc);
1222 lower = TO_NATIVE(*((uint16_t *)loc + 1));
1223
1224 sign = (upper >> 10) & 1;
1225 j1 = (lower >> 13) & 1;
1226 j2 = (lower >> 11) & 1;
1227 offset = sign_extend32((sign << 24) |
1228 ((~(j1 ^ sign) & 1) << 23) |
1229 ((~(j2 ^ sign) & 1) << 22) |
1230 ((upper & 0x03ff) << 12) |
1231 ((lower & 0x07ff) << 1),
1232 24);
1233 return offset + sym->st_value + 4;
1234 }
1235
1236 return (Elf_Addr)(-1);
1237 }
1238
1239 static Elf_Addr addend_mips_rel(uint32_t *location, unsigned int r_type)
1240 {
1241 uint32_t inst;
1242
1243 inst = TO_NATIVE(*location);
1244 switch (r_type) {
1245 case R_MIPS_LO16:
1246 return inst & 0xffff;
1247 case R_MIPS_26:
1248 return (inst & 0x03ffffff) << 2;
1249 case R_MIPS_32:
1250 return inst;
1251 }
1252 return (Elf_Addr)(-1);
1253 }
1254
1255 #ifndef EM_RISCV
1256 #define EM_RISCV 243
1257 #endif
1258
1259 #ifndef R_RISCV_SUB32
1260 #define R_RISCV_SUB32 39
1261 #endif
1262
1263 #ifndef EM_LOONGARCH
1264 #define EM_LOONGARCH 258
1265 #endif
1266
1267 #ifndef R_LARCH_SUB32
1268 #define R_LARCH_SUB32 55
1269 #endif
1270
1271 #ifndef R_LARCH_RELAX
1272 #define R_LARCH_RELAX 100
1273 #endif
1274
1275 #ifndef R_LARCH_ALIGN
1276 #define R_LARCH_ALIGN 102
1277 #endif
1278
1279 static void get_rel_type_and_sym(struct elf_info *elf, uint64_t r_info,
1280 unsigned int *r_type, unsigned int *r_sym)
1281 {
1282 typedef struct {
1283 Elf64_Word r_sym; /* Symbol index */
1284 unsigned char r_ssym; /* Special symbol for 2nd relocation */
1285 unsigned char r_type3; /* 3rd relocation type */
1286 unsigned char r_type2; /* 2nd relocation type */
1287 unsigned char r_type; /* 1st relocation type */
1288 } Elf64_Mips_R_Info;
1289
1290 bool is_64bit = (elf->hdr->e_ident[EI_CLASS] == ELFCLASS64);
1291
1292 if (elf->hdr->e_machine == EM_MIPS && is_64bit) {
1293 Elf64_Mips_R_Info *mips64_r_info = (void *)&r_info;
1294
1295 *r_type = mips64_r_info->r_type;
1296 *r_sym = TO_NATIVE(mips64_r_info->r_sym);
1297 return;
1298 }
1299
1300 if (is_64bit)
1301 r_info = TO_NATIVE((Elf64_Xword)r_info);
1302 else
1303 r_info = TO_NATIVE((Elf32_Word)r_info);
1304
1305 *r_type = ELF_R_TYPE(r_info);
1306 *r_sym = ELF_R_SYM(r_info);
1307 }
1308
1309 static void section_rela(struct module *mod, struct elf_info *elf,
1310 unsigned int fsecndx, const char *fromsec,
1311 const Elf_Rela *start, const Elf_Rela *stop)
1312 {
1313 const Elf_Rela *rela;
1314
1315 for (rela = start; rela < stop; rela++) {
1316 Elf_Sym *tsym;
1317 Elf_Addr taddr, r_offset;
1318 unsigned int r_type, r_sym;
1319
1320 r_offset = TO_NATIVE(rela->r_offset);
1321 get_rel_type_and_sym(elf, rela->r_info, &r_type, &r_sym);
1322
1323 tsym = elf->symtab_start + r_sym;
1324 taddr = tsym->st_value + TO_NATIVE(rela->r_addend);
1325
1326 switch (elf->hdr->e_machine) {
1327 case EM_RISCV:
1328 if (!strcmp("__ex_table", fromsec) &&
1329 r_type == R_RISCV_SUB32)
1330 continue;
1331 break;
1332 case EM_LOONGARCH:
1333 switch (r_type) {
1334 case R_LARCH_SUB32:
1335 if (!strcmp("__ex_table", fromsec))
1336 continue;
1337 break;
1338 case R_LARCH_RELAX:
1339 case R_LARCH_ALIGN:
1340 /* These relocs do not refer to symbols */
1341 continue;
1342 }
1343 break;
1344 }
1345
1346 check_section_mismatch(mod, elf, tsym,
1347 fsecndx, fromsec, r_offset, taddr);
1348 }
1349 }
1350
1351 static void section_rel(struct module *mod, struct elf_info *elf,
1352 unsigned int fsecndx, const char *fromsec,
1353 const Elf_Rel *start, const Elf_Rel *stop)
1354 {
1355 const Elf_Rel *rel;
1356
1357 for (rel = start; rel < stop; rel++) {
1358 Elf_Sym *tsym;
1359 Elf_Addr taddr, r_offset;
1360 unsigned int r_type, r_sym;
1361 void *loc;
1362
1363 r_offset = TO_NATIVE(rel->r_offset);
1364 get_rel_type_and_sym(elf, rel->r_info, &r_type, &r_sym);
1365
1366 loc = sym_get_data_by_offset(elf, fsecndx, r_offset);
1367 tsym = elf->symtab_start + r_sym;
1368
1369 switch (elf->hdr->e_machine) {
1370 case EM_386:
1371 taddr = addend_386_rel(loc, r_type);
1372 break;
1373 case EM_ARM:
1374 taddr = addend_arm_rel(loc, tsym, r_type);
1375 break;
1376 case EM_MIPS:
1377 taddr = addend_mips_rel(loc, r_type);
1378 break;
1379 default:
1380 fatal("Please add code to calculate addend for this architecture\n");
1381 }
1382
1383 check_section_mismatch(mod, elf, tsym,
1384 fsecndx, fromsec, r_offset, taddr);
1385 }
1386 }
1387
1388 /**
1389 * A module includes a number of sections that are discarded
1390 * either when loaded or when used as built-in.
1391 * For loaded modules all functions marked __init and all data
1392 * marked __initdata will be discarded when the module has been initialized.
1393 * Likewise for modules used built-in the sections marked __exit
1394 * are discarded because __exit marked function are supposed to be called
1395 * only when a module is unloaded which never happens for built-in modules.
1396 * The check_sec_ref() function traverses all relocation records
1397 * to find all references to a section that reference a section that will
1398 * be discarded and warns about it.
1399 **/
1400 static void check_sec_ref(struct module *mod, struct elf_info *elf)
1401 {
1402 int i;
1403
1404 /* Walk through all sections */
1405 for (i = 0; i < elf->num_sections; i++) {
1406 Elf_Shdr *sechdr = &elf->sechdrs[i];
1407
1408 check_section(mod->name, elf, sechdr);
1409 /* We want to process only relocation sections and not .init */
1410 if (sechdr->sh_type == SHT_REL || sechdr->sh_type == SHT_RELA) {
1411 /* section to which the relocation applies */
1412 unsigned int secndx = sechdr->sh_info;
1413 const char *secname = sec_name(elf, secndx);
1414 const void *start, *stop;
1415
1416 /* If the section is known good, skip it */
1417 if (match(secname, section_white_list))
1418 continue;
1419
1420 start = sym_get_data_by_offset(elf, i, 0);
1421 stop = start + sechdr->sh_size;
1422
1423 if (sechdr->sh_type == SHT_RELA)
1424 section_rela(mod, elf, secndx, secname,
1425 start, stop);
1426 else
1427 section_rel(mod, elf, secndx, secname,
1428 start, stop);
1429 }
1430 }
1431 }
1432
1433 static char *remove_dot(char *s)
1434 {
1435 size_t n = strcspn(s, ".");
1436
1437 if (n && s[n]) {
1438 size_t m = strspn(s + n + 1, "0123456789");
1439 if (m && (s[n + m + 1] == '.' || s[n + m + 1] == 0))
1440 s[n] = 0;
1441 }
1442 return s;
1443 }
1444
1445 /*
1446 * The CRCs are recorded in .*.cmd files in the form of:
1447 * #SYMVER <name> <crc>
1448 */
1449 static void extract_crcs_for_object(const char *object, struct module *mod)
1450 {
1451 char cmd_file[PATH_MAX];
1452 char *buf, *p;
1453 const char *base;
1454 int dirlen, ret;
1455
1456 base = strrchr(object, '/');
1457 if (base) {
1458 base++;
1459 dirlen = base - object;
1460 } else {
1461 dirlen = 0;
1462 base = object;
1463 }
1464
1465 ret = snprintf(cmd_file, sizeof(cmd_file), "%.*s.%s.cmd",
1466 dirlen, object, base);
1467 if (ret >= sizeof(cmd_file)) {
1468 error("%s: too long path was truncated\n", cmd_file);
1469 return;
1470 }
1471
1472 buf = read_text_file(cmd_file);
1473 p = buf;
1474
1475 while ((p = strstr(p, "\n#SYMVER "))) {
1476 char *name;
1477 size_t namelen;
1478 unsigned int crc;
1479 struct symbol *sym;
1480
1481 name = p + strlen("\n#SYMVER ");
1482
1483 p = strchr(name, ' ');
1484 if (!p)
1485 break;
1486
1487 namelen = p - name;
1488 p++;
1489
1490 if (!isdigit(*p))
1491 continue; /* skip this line */
1492
1493 crc = strtoul(p, &p, 0);
1494 if (*p != '\n')
1495 continue; /* skip this line */
1496
1497 name[namelen] = '\0';
1498
1499 /*
1500 * sym_find_with_module() may return NULL here.
1501 * It typically occurs when CONFIG_TRIM_UNUSED_KSYMS=y.
1502 * Since commit e1327a127703, genksyms calculates CRCs of all
1503 * symbols, including trimmed ones. Ignore orphan CRCs.
1504 */
1505 sym = sym_find_with_module(name, mod);
1506 if (sym)
1507 sym_set_crc(sym, crc);
1508 }
1509
1510 free(buf);
1511 }
1512
1513 /*
1514 * The symbol versions (CRC) are recorded in the .*.cmd files.
1515 * Parse them to retrieve CRCs for the current module.
1516 */
1517 static void mod_set_crcs(struct module *mod)
1518 {
1519 char objlist[PATH_MAX];
1520 char *buf, *p, *obj;
1521 int ret;
1522
1523 if (mod->is_vmlinux) {
1524 strcpy(objlist, ".vmlinux.objs");
1525 } else {
1526 /* objects for a module are listed in the *.mod file. */
1527 ret = snprintf(objlist, sizeof(objlist), "%s.mod", mod->name);
1528 if (ret >= sizeof(objlist)) {
1529 error("%s: too long path was truncated\n", objlist);
1530 return;
1531 }
1532 }
1533
1534 buf = read_text_file(objlist);
1535 p = buf;
1536
1537 while ((obj = strsep(&p, "\n")) && obj[0])
1538 extract_crcs_for_object(obj, mod);
1539
1540 free(buf);
1541 }
1542
1543 static void read_symbols(const char *modname)
1544 {
1545 const char *symname;
1546 char *version;
1547 char *license;
1548 char *namespace;
1549 struct module *mod;
1550 struct elf_info info = { };
1551 Elf_Sym *sym;
1552
1553 if (!parse_elf(&info, modname))
1554 return;
1555
1556 if (!strends(modname, ".o")) {
1557 error("%s: filename must be suffixed with .o\n", modname);
1558 return;
1559 }
1560
1561 /* strip trailing .o */
1562 mod = new_module(modname, strlen(modname) - strlen(".o"));
1563
1564 if (!mod->is_vmlinux) {
1565 license = get_modinfo(&info, "license");
1566 if (!license)
1567 error("missing MODULE_LICENSE() in %s\n", modname);
1568 while (license) {
1569 if (!license_is_gpl_compatible(license)) {
1570 mod->is_gpl_compatible = false;
1571 break;
1572 }
1573 license = get_next_modinfo(&info, "license", license);
1574 }
1575
1576 namespace = get_modinfo(&info, "import_ns");
1577 while (namespace) {
1578 add_namespace(&mod->imported_namespaces, namespace);
1579 namespace = get_next_modinfo(&info, "import_ns",
1580 namespace);
1581 }
1582
1583 if (extra_warn && !get_modinfo(&info, "description"))
1584 warn("missing MODULE_DESCRIPTION() in %s\n", modname);
1585 }
1586
1587 for (sym = info.symtab_start; sym < info.symtab_stop; sym++) {
1588 symname = remove_dot(info.strtab + sym->st_name);
1589
1590 handle_symbol(mod, &info, sym, symname);
1591 handle_moddevtable(mod, &info, sym, symname);
1592 }
1593
1594 check_sec_ref(mod, &info);
1595
1596 if (!mod->is_vmlinux) {
1597 version = get_modinfo(&info, "version");
1598 if (version || all_versions)
1599 get_src_version(mod->name, mod->srcversion,
1600 sizeof(mod->srcversion) - 1);
1601 }
1602
1603 parse_elf_finish(&info);
1604
1605 if (modversions) {
1606 /*
1607 * Our trick to get versioning for module struct etc. - it's
1608 * never passed as an argument to an exported function, so
1609 * the automatic versioning doesn't pick it up, but it's really
1610 * important anyhow.
1611 */
1612 sym_add_unresolved("module_layout", mod, false);
1613
1614 mod_set_crcs(mod);
1615 }
1616 }
1617
1618 static void read_symbols_from_files(const char *filename)
1619 {
1620 FILE *in = stdin;
1621 char fname[PATH_MAX];
1622
1623 in = fopen(filename, "r");
1624 if (!in)
1625 fatal("Can't open filenames file %s: %m", filename);
1626
1627 while (fgets(fname, PATH_MAX, in) != NULL) {
1628 if (strends(fname, "\n"))
1629 fname[strlen(fname)-1] = '\0';
1630 read_symbols(fname);
1631 }
1632
1633 fclose(in);
1634 }
1635
1636 #define SZ 500
1637
1638 /* We first write the generated file into memory using the
1639 * following helper, then compare to the file on disk and
1640 * only update the later if anything changed */
1641
1642 void __attribute__((format(printf, 2, 3))) buf_printf(struct buffer *buf,
1643 const char *fmt, ...)
1644 {
1645 char tmp[SZ];
1646 int len;
1647 va_list ap;
1648
1649 va_start(ap, fmt);
1650 len = vsnprintf(tmp, SZ, fmt, ap);
1651 buf_write(buf, tmp, len);
1652 va_end(ap);
1653 }
1654
1655 void buf_write(struct buffer *buf, const char *s, int len)
1656 {
1657 if (buf->size - buf->pos < len) {
1658 buf->size += len + SZ;
1659 buf->p = xrealloc(buf->p, buf->size);
1660 }
1661 strncpy(buf->p + buf->pos, s, len);
1662 buf->pos += len;
1663 }
1664
1665 static void check_exports(struct module *mod)
1666 {
1667 struct symbol *s, *exp;
1668
1669 list_for_each_entry(s, &mod->unresolved_symbols, list) {
1670 const char *basename;
1671 exp = find_symbol(s->name);
1672 if (!exp) {
1673 if (!s->weak && nr_unresolved++ < MAX_UNRESOLVED_REPORTS)
1674 modpost_log(!warn_unresolved,
1675 "\"%s\" [%s.ko] undefined!\n",
1676 s->name, mod->name);
1677 continue;
1678 }
1679 if (exp->module == mod) {
1680 error("\"%s\" [%s.ko] was exported without definition\n",
1681 s->name, mod->name);
1682 continue;
1683 }
1684
1685 exp->used = true;
1686 s->module = exp->module;
1687 s->crc_valid = exp->crc_valid;
1688 s->crc = exp->crc;
1689
1690 basename = strrchr(mod->name, '/');
1691 if (basename)
1692 basename++;
1693 else
1694 basename = mod->name;
1695
1696 if (!contains_namespace(&mod->imported_namespaces, exp->namespace)) {
1697 modpost_log(!allow_missing_ns_imports,
1698 "module %s uses symbol %s from namespace %s, but does not import it.\n",
1699 basename, exp->name, exp->namespace);
1700 add_namespace(&mod->missing_namespaces, exp->namespace);
1701 }
1702
1703 if (!mod->is_gpl_compatible && exp->is_gpl_only)
1704 error("GPL-incompatible module %s.ko uses GPL-only symbol '%s'\n",
1705 basename, exp->name);
1706 }
1707 }
1708
1709 static void handle_white_list_exports(const char *white_list)
1710 {
1711 char *buf, *p, *name;
1712
1713 buf = read_text_file(white_list);
1714 p = buf;
1715
1716 while ((name = strsep(&p, "\n"))) {
1717 struct symbol *sym = find_symbol(name);
1718
1719 if (sym)
1720 sym->used = true;
1721 }
1722
1723 free(buf);
1724 }
1725
1726 static void check_modname_len(struct module *mod)
1727 {
1728 const char *mod_name;
1729
1730 mod_name = strrchr(mod->name, '/');
1731 if (mod_name == NULL)
1732 mod_name = mod->name;
1733 else
1734 mod_name++;
1735 if (strlen(mod_name) >= MODULE_NAME_LEN)
1736 error("module name is too long [%s.ko]\n", mod->name);
1737 }
1738
1739 /**
1740 * Header for the generated file
1741 **/
1742 static void add_header(struct buffer *b, struct module *mod)
1743 {
1744 buf_printf(b, "#include <linux/module.h>\n");
1745 buf_printf(b, "#include <linux/export-internal.h>\n");
1746 buf_printf(b, "#include <linux/compiler.h>\n");
1747 buf_printf(b, "\n");
1748 buf_printf(b, "MODULE_INFO(name, KBUILD_MODNAME);\n");
1749 buf_printf(b, "\n");
1750 buf_printf(b, "__visible struct module __this_module\n");
1751 buf_printf(b, "__section(\".gnu.linkonce.this_module\") = {\n");
1752 buf_printf(b, "\t.name = KBUILD_MODNAME,\n");
1753 if (mod->has_init)
1754 buf_printf(b, "\t.init = init_module,\n");
1755 if (mod->has_cleanup)
1756 buf_printf(b, "#ifdef CONFIG_MODULE_UNLOAD\n"
1757 "\t.exit = cleanup_module,\n"
1758 "#endif\n");
1759 buf_printf(b, "\t.arch = MODULE_ARCH_INIT,\n");
1760 buf_printf(b, "};\n");
1761
1762 if (!external_module)
1763 buf_printf(b, "\nMODULE_INFO(intree, \"Y\");\n");
1764
1765 if (strstarts(mod->name, "drivers/staging"))
1766 buf_printf(b, "\nMODULE_INFO(staging, \"Y\");\n");
1767
1768 if (strstarts(mod->name, "tools/testing"))
1769 buf_printf(b, "\nMODULE_INFO(test, \"Y\");\n");
1770 }
1771
1772 static void add_exported_symbols(struct buffer *buf, struct module *mod)
1773 {
1774 struct symbol *sym;
1775
1776 /* generate struct for exported symbols */
1777 buf_printf(buf, "\n");
1778 list_for_each_entry(sym, &mod->exported_symbols, list) {
1779 if (trim_unused_exports && !sym->used)
1780 continue;
1781
1782 buf_printf(buf, "KSYMTAB_%s(%s, \"%s\", \"%s\");\n",
1783 sym->is_func ? "FUNC" : "DATA", sym->name,
1784 sym->is_gpl_only ? "_gpl" : "", sym->namespace);
1785 }
1786
1787 if (!modversions)
1788 return;
1789
1790 /* record CRCs for exported symbols */
1791 buf_printf(buf, "\n");
1792 list_for_each_entry(sym, &mod->exported_symbols, list) {
1793 if (trim_unused_exports && !sym->used)
1794 continue;
1795
1796 if (!sym->crc_valid)
1797 warn("EXPORT symbol \"%s\" [%s%s] version generation failed, symbol will not be versioned.\n"
1798 "Is \"%s\" prototyped in <asm/asm-prototypes.h>?\n",
1799 sym->name, mod->name, mod->is_vmlinux ? "" : ".ko",
1800 sym->name);
1801
1802 buf_printf(buf, "SYMBOL_CRC(%s, 0x%08x, \"%s\");\n",
1803 sym->name, sym->crc, sym->is_gpl_only ? "_gpl" : "");
1804 }
1805 }
1806
1807 /**
1808 * Record CRCs for unresolved symbols
1809 **/
1810 static void add_versions(struct buffer *b, struct module *mod)
1811 {
1812 struct symbol *s;
1813
1814 if (!modversions)
1815 return;
1816
1817 buf_printf(b, "\n");
1818 buf_printf(b, "static const struct modversion_info ____versions[]\n");
1819 buf_printf(b, "__used __section(\"__versions\") = {\n");
1820
1821 list_for_each_entry(s, &mod->unresolved_symbols, list) {
1822 if (!s->module)
1823 continue;
1824 if (!s->crc_valid) {
1825 warn("\"%s\" [%s.ko] has no CRC!\n",
1826 s->name, mod->name);
1827 continue;
1828 }
1829 if (strlen(s->name) >= MODULE_NAME_LEN) {
1830 error("too long symbol \"%s\" [%s.ko]\n",
1831 s->name, mod->name);
1832 break;
1833 }
1834 buf_printf(b, "\t{ %#8x, \"%s\" },\n",
1835 s->crc, s->name);
1836 }
1837
1838 buf_printf(b, "};\n");
1839 }
1840
1841 static void add_depends(struct buffer *b, struct module *mod)
1842 {
1843 struct symbol *s;
1844 int first = 1;
1845
1846 /* Clear ->seen flag of modules that own symbols needed by this. */
1847 list_for_each_entry(s, &mod->unresolved_symbols, list) {
1848 if (s->module)
1849 s->module->seen = s->module->is_vmlinux;
1850 }
1851
1852 buf_printf(b, "\n");
1853 buf_printf(b, "MODULE_INFO(depends, \"");
1854 list_for_each_entry(s, &mod->unresolved_symbols, list) {
1855 const char *p;
1856 if (!s->module)
1857 continue;
1858
1859 if (s->module->seen)
1860 continue;
1861
1862 s->module->seen = true;
1863 p = strrchr(s->module->name, '/');
1864 if (p)
1865 p++;
1866 else
1867 p = s->module->name;
1868 buf_printf(b, "%s%s", first ? "" : ",", p);
1869 first = 0;
1870 }
1871 buf_printf(b, "\");\n");
1872 }
1873
1874 static void add_srcversion(struct buffer *b, struct module *mod)
1875 {
1876 if (mod->srcversion[0]) {
1877 buf_printf(b, "\n");
1878 buf_printf(b, "MODULE_INFO(srcversion, \"%s\");\n",
1879 mod->srcversion);
1880 }
1881 }
1882
1883 static void write_buf(struct buffer *b, const char *fname)
1884 {
1885 FILE *file;
1886
1887 if (error_occurred)
1888 return;
1889
1890 file = fopen(fname, "w");
1891 if (!file) {
1892 perror(fname);
1893 exit(1);
1894 }
1895 if (fwrite(b->p, 1, b->pos, file) != b->pos) {
1896 perror(fname);
1897 exit(1);
1898 }
1899 if (fclose(file) != 0) {
1900 perror(fname);
1901 exit(1);
1902 }
1903 }
1904
1905 static void write_if_changed(struct buffer *b, const char *fname)
1906 {
1907 char *tmp;
1908 FILE *file;
1909 struct stat st;
1910
1911 file = fopen(fname, "r");
1912 if (!file)
1913 goto write;
1914
1915 if (fstat(fileno(file), &st) < 0)
1916 goto close_write;
1917
1918 if (st.st_size != b->pos)
1919 goto close_write;
1920
1921 tmp = xmalloc(b->pos);
1922 if (fread(tmp, 1, b->pos, file) != b->pos)
1923 goto free_write;
1924
1925 if (memcmp(tmp, b->p, b->pos) != 0)
1926 goto free_write;
1927
1928 free(tmp);
1929 fclose(file);
1930 return;
1931
1932 free_write:
1933 free(tmp);
1934 close_write:
1935 fclose(file);
1936 write:
1937 write_buf(b, fname);
1938 }
1939
1940 static void write_vmlinux_export_c_file(struct module *mod)
1941 {
1942 struct buffer buf = { };
1943
1944 buf_printf(&buf,
1945 "#include <linux/export-internal.h>\n");
1946
1947 add_exported_symbols(&buf, mod);
1948 write_if_changed(&buf, ".vmlinux.export.c");
1949 free(buf.p);
1950 }
1951
1952 /* do sanity checks, and generate *.mod.c file */
1953 static void write_mod_c_file(struct module *mod)
1954 {
1955 struct buffer buf = { };
1956 struct module_alias *alias, *next;
1957 char fname[PATH_MAX];
1958 int ret;
1959
1960 add_header(&buf, mod);
1961 add_exported_symbols(&buf, mod);
1962 add_versions(&buf, mod);
1963 add_depends(&buf, mod);
1964
1965 buf_printf(&buf, "\n");
1966 list_for_each_entry_safe(alias, next, &mod->aliases, node) {
1967 buf_printf(&buf, "MODULE_ALIAS(\"%s\");\n", alias->str);
1968 list_del(&alias->node);
1969 free(alias);
1970 }
1971
1972 add_srcversion(&buf, mod);
1973
1974 ret = snprintf(fname, sizeof(fname), "%s.mod.c", mod->name);
1975 if (ret >= sizeof(fname)) {
1976 error("%s: too long path was truncated\n", fname);
1977 goto free;
1978 }
1979
1980 write_if_changed(&buf, fname);
1981
1982 free:
1983 free(buf.p);
1984 }
1985
1986 /* parse Module.symvers file. line format:
1987 * 0x12345678<tab>symbol<tab>module<tab>export<tab>namespace
1988 **/
1989 static void read_dump(const char *fname)
1990 {
1991 char *buf, *pos, *line;
1992
1993 buf = read_text_file(fname);
1994 if (!buf)
1995 /* No symbol versions, silently ignore */
1996 return;
1997
1998 pos = buf;
1999
2000 while ((line = get_line(&pos))) {
2001 char *symname, *namespace, *modname, *d, *export;
2002 unsigned int crc;
2003 struct module *mod;
2004 struct symbol *s;
2005 bool gpl_only;
2006
2007 if (!(symname = strchr(line, '\t')))
2008 goto fail;
2009 *symname++ = '\0';
2010 if (!(modname = strchr(symname, '\t')))
2011 goto fail;
2012 *modname++ = '\0';
2013 if (!(export = strchr(modname, '\t')))
2014 goto fail;
2015 *export++ = '\0';
2016 if (!(namespace = strchr(export, '\t')))
2017 goto fail;
2018 *namespace++ = '\0';
2019
2020 crc = strtoul(line, &d, 16);
2021 if (*symname == '\0' || *modname == '\0' || *d != '\0')
2022 goto fail;
2023
2024 if (!strcmp(export, "EXPORT_SYMBOL_GPL")) {
2025 gpl_only = true;
2026 } else if (!strcmp(export, "EXPORT_SYMBOL")) {
2027 gpl_only = false;
2028 } else {
2029 error("%s: unknown license %s. skip", symname, export);
2030 continue;
2031 }
2032
2033 mod = find_module(modname);
2034 if (!mod) {
2035 mod = new_module(modname, strlen(modname));
2036 mod->from_dump = true;
2037 }
2038 s = sym_add_exported(symname, mod, gpl_only, namespace);
2039 sym_set_crc(s, crc);
2040 }
2041 free(buf);
2042 return;
2043 fail:
2044 free(buf);
2045 fatal("parse error in symbol dump file\n");
2046 }
2047
2048 static void write_dump(const char *fname)
2049 {
2050 struct buffer buf = { };
2051 struct module *mod;
2052 struct symbol *sym;
2053
2054 list_for_each_entry(mod, &modules, list) {
2055 if (mod->from_dump)
2056 continue;
2057 list_for_each_entry(sym, &mod->exported_symbols, list) {
2058 if (trim_unused_exports && !sym->used)
2059 continue;
2060
2061 buf_printf(&buf, "0x%08x\t%s\t%s\tEXPORT_SYMBOL%s\t%s\n",
2062 sym->crc, sym->name, mod->name,
2063 sym->is_gpl_only ? "_GPL" : "",
2064 sym->namespace);
2065 }
2066 }
2067 write_buf(&buf, fname);
2068 free(buf.p);
2069 }
2070
2071 static void write_namespace_deps_files(const char *fname)
2072 {
2073 struct module *mod;
2074 struct namespace_list *ns;
2075 struct buffer ns_deps_buf = {};
2076
2077 list_for_each_entry(mod, &modules, list) {
2078
2079 if (mod->from_dump || list_empty(&mod->missing_namespaces))
2080 continue;
2081
2082 buf_printf(&ns_deps_buf, "%s.ko:", mod->name);
2083
2084 list_for_each_entry(ns, &mod->missing_namespaces, list)
2085 buf_printf(&ns_deps_buf, " %s", ns->namespace);
2086
2087 buf_printf(&ns_deps_buf, "\n");
2088 }
2089
2090 write_if_changed(&ns_deps_buf, fname);
2091 free(ns_deps_buf.p);
2092 }
2093
2094 struct dump_list {
2095 struct list_head list;
2096 const char *file;
2097 };
2098
2099 static void check_host_endian(void)
2100 {
2101 static const union {
2102 short s;
2103 char c[2];
2104 } endian_test = { .c = {0x01, 0x02} };
2105
2106 switch (endian_test.s) {
2107 case 0x0102:
2108 host_is_big_endian = true;
2109 break;
2110 case 0x0201:
2111 host_is_big_endian = false;
2112 break;
2113 default:
2114 fatal("Unknown host endian\n");
2115 }
2116 }
2117
2118 int main(int argc, char **argv)
2119 {
2120 struct module *mod;
2121 char *missing_namespace_deps = NULL;
2122 char *unused_exports_white_list = NULL;
2123 char *dump_write = NULL, *files_source = NULL;
2124 int opt;
2125 LIST_HEAD(dump_lists);
2126 struct dump_list *dl, *dl2;
2127
2128 while ((opt = getopt(argc, argv, "ei:MmnT:to:au:WwENd:")) != -1) {
2129 switch (opt) {
2130 case 'e':
2131 external_module = true;
2132 break;
2133 case 'i':
2134 dl = xmalloc(sizeof(*dl));
2135 dl->file = optarg;
2136 list_add_tail(&dl->list, &dump_lists);
2137 break;
2138 case 'M':
2139 module_enabled = true;
2140 break;
2141 case 'm':
2142 modversions = true;
2143 break;
2144 case 'n':
2145 ignore_missing_files = true;
2146 break;
2147 case 'o':
2148 dump_write = optarg;
2149 break;
2150 case 'a':
2151 all_versions = true;
2152 break;
2153 case 'T':
2154 files_source = optarg;
2155 break;
2156 case 't':
2157 trim_unused_exports = true;
2158 break;
2159 case 'u':
2160 unused_exports_white_list = optarg;
2161 break;
2162 case 'W':
2163 extra_warn = true;
2164 break;
2165 case 'w':
2166 warn_unresolved = true;
2167 break;
2168 case 'E':
2169 sec_mismatch_warn_only = false;
2170 break;
2171 case 'N':
2172 allow_missing_ns_imports = true;
2173 break;
2174 case 'd':
2175 missing_namespace_deps = optarg;
2176 break;
2177 default:
2178 exit(1);
2179 }
2180 }
2181
2182 check_host_endian();
2183
2184 list_for_each_entry_safe(dl, dl2, &dump_lists, list) {
2185 read_dump(dl->file);
2186 list_del(&dl->list);
2187 free(dl);
2188 }
2189
2190 while (optind < argc)
2191 read_symbols(argv[optind++]);
2192
2193 if (files_source)
2194 read_symbols_from_files(files_source);
2195
2196 list_for_each_entry(mod, &modules, list) {
2197 if (mod->from_dump || mod->is_vmlinux)
2198 continue;
2199
2200 check_modname_len(mod);
2201 check_exports(mod);
2202 }
2203
2204 if (unused_exports_white_list)
2205 handle_white_list_exports(unused_exports_white_list);
2206
2207 list_for_each_entry(mod, &modules, list) {
2208 if (mod->from_dump)
2209 continue;
2210
2211 if (mod->is_vmlinux)
2212 write_vmlinux_export_c_file(mod);
2213 else
2214 write_mod_c_file(mod);
2215 }
2216
2217 if (missing_namespace_deps)
2218 write_namespace_deps_files(missing_namespace_deps);
2219
2220 if (dump_write)
2221 write_dump(dump_write);
2222 if (sec_mismatch_count && !sec_mismatch_warn_only)
2223 error("Section mismatches detected.\n"
2224 "Set CONFIG_SECTION_MISMATCH_WARN_ONLY=y to allow them.\n");
2225
2226 if (nr_unresolved > MAX_UNRESOLVED_REPORTS)
2227 warn("suppressed %u unresolved symbol warnings because there were too many)\n",
2228 nr_unresolved - MAX_UNRESOLVED_REPORTS);
2229
2230 return error_occurred ? 1 : 0;
2231 }
Kernel DRM miscellaneous fixes and cross-tree changes