scripts/mod/modpost.c

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