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