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