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