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