scripts/mod/modpost.c

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