scripts/mod/modpost.c

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