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