scripts/mod/modpost.c

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