scripts/mod/modpost.c

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