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