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