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