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