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 ...\n"
 664                      "Is \"%s\" prototyped in <asm/asm-prototypes.h>?\n",
 665                      symname, mod->name, mod->is_vmlinux ? "" : ".ko",
 666                      symname);
 667
 668                 return;
 669         }
 670
 671         if (sym->st_shndx == SHN_ABS) {
 672                 crc = sym->st_value;
 673         } else {
 674                 unsigned int *crcp;
 675
 676                 /* symbol points to the CRC in the ELF object */
 677                 crcp = sym_get_data(info, sym);
 678                 crc = TO_NATIVE(*crcp);
 679         }
 680         sym_set_crc(symname, crc);
 681 }
 682
 683 static void handle_symbol(struct module *mod, struct elf_info *info,
 684                           const Elf_Sym *sym, const char *symname)
 685 {
 686         enum export export;
 687         const char *name;
 688
 689         if (strstarts(symname, "__ksymtab"))
 690                 export = export_from_secname(info, get_secindex(info, sym));
 691         else
 692                 export = export_from_sec(info, get_secindex(info, sym));
 693
 694         switch (sym->st_shndx) {
 695         case SHN_COMMON:
 696                 if (strstarts(symname, "__gnu_lto_")) {
 697                         /* Should warn here, but modpost runs before the linker */
 698                 } else
 699                         warn("\"%s\" [%s] is COMMON symbol\n", symname, mod->name);
 700                 break;
 701         case SHN_UNDEF:
 702                 /* undefined symbol */
 703                 if (ELF_ST_BIND(sym->st_info) != STB_GLOBAL &&
 704                     ELF_ST_BIND(sym->st_info) != STB_WEAK)
 705                         break;
 706                 if (ignore_undef_symbol(info, symname))
 707                         break;
 708                 if (info->hdr->e_machine == EM_SPARC ||
 709                     info->hdr->e_machine == EM_SPARCV9) {
 710                         /* Ignore register directives. */
 711                         if (ELF_ST_TYPE(sym->st_info) == STT_SPARC_REGISTER)
 712                                 break;
 713                         if (symname[0] == '.') {
 714                                 char *munged = NOFAIL(strdup(symname));
 715                                 munged[0] = '_';
 716                                 munged[1] = toupper(munged[1]);
 717                                 symname = munged;
 718                         }
 719                 }
 720
 721                 mod->unres = alloc_symbol(symname,
 722                                           ELF_ST_BIND(sym->st_info) == STB_WEAK,
 723                                           mod->unres);
 724                 break;
 725         default:
 726                 /* All exported symbols */
 727                 if (strstarts(symname, "__ksymtab_")) {
 728                         name = symname + strlen("__ksymtab_");
 729                         sym_add_exported(name, mod, export);
 730                 }
 731                 if (strcmp(symname, "init_module") == 0)
 732                         mod->has_init = 1;
 733                 if (strcmp(symname, "cleanup_module") == 0)
 734                         mod->has_cleanup = 1;
 735                 break;
 736         }
 737 }
 738
 739 /**
 740  * Parse tag=value strings from .modinfo section
 741  **/
 742 static char *next_string(char *string, unsigned long *secsize)
 743 {
 744         /* Skip non-zero chars */
 745         while (string[0]) {
 746                 string++;
 747                 if ((*secsize)-- <= 1)
 748                         return NULL;
 749         }
 750
 751         /* Skip any zero padding. */
 752         while (!string[0]) {
 753                 string++;
 754                 if ((*secsize)-- <= 1)
 755                         return NULL;
 756         }
 757         return string;
 758 }
 759
 760 static char *get_next_modinfo(struct elf_info *info, const char *tag,
 761                               char *prev)
 762 {
 763         char *p;
 764         unsigned int taglen = strlen(tag);
 765         char *modinfo = info->modinfo;
 766         unsigned long size = info->modinfo_len;
 767
 768         if (prev) {
 769                 size -= prev - modinfo;
 770                 modinfo = next_string(prev, &size);
 771         }
 772
 773         for (p = modinfo; p; p = next_string(p, &size)) {
 774                 if (strncmp(p, tag, taglen) == 0 && p[taglen] == '=')
 775                         return p + taglen + 1;
 776         }
 777         return NULL;
 778 }
 779
 780 static char *get_modinfo(struct elf_info *info, const char *tag)
 781
 782 {
 783         return get_next_modinfo(info, tag, NULL);
 784 }
 785
 786 /**
 787  * Test if string s ends in string sub
 788  * return 0 if match
 789  **/
 790 static int strrcmp(const char *s, const char *sub)
 791 {
 792         int slen, sublen;
 793
 794         if (!s || !sub)
 795                 return 1;
 796
 797         slen = strlen(s);
 798         sublen = strlen(sub);
 799
 800         if ((slen == 0) || (sublen == 0))
 801                 return 1;
 802
 803         if (sublen > slen)
 804                 return 1;
 805
 806         return memcmp(s + slen - sublen, sub, sublen);
 807 }
 808
 809 static const char *sym_name(struct elf_info *elf, Elf_Sym *sym)
 810 {
 811         if (sym)
 812                 return elf->strtab + sym->st_name;
 813         else
 814                 return "(unknown)";
 815 }
 816
 817 /* The pattern is an array of simple patterns.
 818  * "foo" will match an exact string equal to "foo"
 819  * "*foo" will match a string that ends with "foo"
 820  * "foo*" will match a string that begins with "foo"
 821  * "*foo*" will match a string that contains "foo"
 822  */
 823 static int match(const char *sym, const char * const pat[])
 824 {
 825         const char *p;
 826         while (*pat) {
 827                 p = *pat++;
 828                 const char *endp = p + strlen(p) - 1;
 829
 830                 /* "*foo*" */
 831                 if (*p == '*' && *endp == '*') {
 832                         char *bare = NOFAIL(strndup(p + 1, strlen(p) - 2));
 833                         char *here = strstr(sym, bare);
 834
 835                         free(bare);
 836                         if (here != NULL)
 837                                 return 1;
 838                 }
 839                 /* "*foo" */
 840                 else if (*p == '*') {
 841                         if (strrcmp(sym, p + 1) == 0)
 842                                 return 1;
 843                 }
 844                 /* "foo*" */
 845                 else if (*endp == '*') {
 846                         if (strncmp(sym, p, strlen(p) - 1) == 0)
 847                                 return 1;
 848                 }
 849                 /* no wildcards */
 850                 else {
 851                         if (strcmp(p, sym) == 0)
 852                                 return 1;
 853                 }
 854         }
 855         /* no match */
 856         return 0;
 857 }
 858
 859 /* sections that we do not want to do full section mismatch check on */
 860 static const char *const section_white_list[] =
 861 {
 862         ".comment*",
 863         ".debug*",
 864         ".cranges",             /* sh64 */
 865         ".zdebug*",             /* Compressed debug sections. */
 866         ".GCC.command.line",    /* record-gcc-switches */
 867         ".mdebug*",        /* alpha, score, mips etc. */
 868         ".pdr",            /* alpha, score, mips etc. */
 869         ".stab*",
 870         ".note*",
 871         ".got*",
 872         ".toc*",
 873         ".xt.prop",                              /* xtensa */
 874         ".xt.lit",         /* xtensa */
 875         ".arcextmap*",                  /* arc */
 876         ".gnu.linkonce.arcext*",        /* arc : modules */
 877         ".cmem*",                       /* EZchip */
 878         ".fmt_slot*",                   /* EZchip */
 879         ".gnu.lto*",
 880         ".discard.*",
 881         NULL
 882 };
 883
 884 /*
 885  * This is used to find sections missing the SHF_ALLOC flag.
 886  * The cause of this is often a section specified in assembler
 887  * without "ax" / "aw".
 888  */
 889 static void check_section(const char *modname, struct elf_info *elf,
 890                           Elf_Shdr *sechdr)
 891 {
 892         const char *sec = sech_name(elf, sechdr);
 893
 894         if (sechdr->sh_type == SHT_PROGBITS &&
 895             !(sechdr->sh_flags & SHF_ALLOC) &&
 896             !match(sec, section_white_list)) {
 897                 warn("%s (%s): unexpected non-allocatable section.\n"
 898                      "Did you forget to use \"ax\"/\"aw\" in a .S file?\n"
 899                      "Note that for example <linux/init.h> contains\n"
 900                      "section definitions for use in .S files.\n\n",
 901                      modname, sec);
 902         }
 903 }
 904
 905
 906
 907 #define ALL_INIT_DATA_SECTIONS \
 908         ".init.setup", ".init.rodata", ".meminit.rodata", \
 909         ".init.data", ".meminit.data"
 910 #define ALL_EXIT_DATA_SECTIONS \
 911         ".exit.data", ".memexit.data"
 912
 913 #define ALL_INIT_TEXT_SECTIONS \
 914         ".init.text", ".meminit.text"
 915 #define ALL_EXIT_TEXT_SECTIONS \
 916         ".exit.text", ".memexit.text"
 917
 918 #define ALL_PCI_INIT_SECTIONS   \
 919         ".pci_fixup_early", ".pci_fixup_header", ".pci_fixup_final", \
 920         ".pci_fixup_enable", ".pci_fixup_resume", \
 921         ".pci_fixup_resume_early", ".pci_fixup_suspend"
 922
 923 #define ALL_XXXINIT_SECTIONS MEM_INIT_SECTIONS
 924 #define ALL_XXXEXIT_SECTIONS MEM_EXIT_SECTIONS
 925
 926 #define ALL_INIT_SECTIONS INIT_SECTIONS, ALL_XXXINIT_SECTIONS
 927 #define ALL_EXIT_SECTIONS EXIT_SECTIONS, ALL_XXXEXIT_SECTIONS
 928
 929 #define DATA_SECTIONS ".data", ".data.rel"
 930 #define TEXT_SECTIONS ".text", ".text.unlikely", ".sched.text", \
 931                 ".kprobes.text", ".cpuidle.text", ".noinstr.text"
 932 #define OTHER_TEXT_SECTIONS ".ref.text", ".head.text", ".spinlock.text", \
 933                 ".fixup", ".entry.text", ".exception.text", ".text.*", \
 934                 ".coldtext"
 935
 936 #define INIT_SECTIONS      ".init.*"
 937 #define MEM_INIT_SECTIONS  ".meminit.*"
 938
 939 #define EXIT_SECTIONS      ".exit.*"
 940 #define MEM_EXIT_SECTIONS  ".memexit.*"
 941
 942 #define ALL_TEXT_SECTIONS  ALL_INIT_TEXT_SECTIONS, ALL_EXIT_TEXT_SECTIONS, \
 943                 TEXT_SECTIONS, OTHER_TEXT_SECTIONS
 944
 945 /* init data sections */
 946 static const char *const init_data_sections[] =
 947         { ALL_INIT_DATA_SECTIONS, NULL };
 948
 949 /* all init sections */
 950 static const char *const init_sections[] = { ALL_INIT_SECTIONS, NULL };
 951
 952 /* All init and exit sections (code + data) */
 953 static const char *const init_exit_sections[] =
 954         {ALL_INIT_SECTIONS, ALL_EXIT_SECTIONS, NULL };
 955
 956 /* all text sections */
 957 static const char *const text_sections[] = { ALL_TEXT_SECTIONS, NULL };
 958
 959 /* data section */
 960 static const char *const data_sections[] = { DATA_SECTIONS, NULL };
 961
 962
 963 /* symbols in .data that may refer to init/exit sections */
 964 #define DEFAULT_SYMBOL_WHITE_LIST                                       \
 965         "*driver",                                                      \
 966         "*_template", /* scsi uses *_template a lot */                  \
 967         "*_timer",    /* arm uses ops structures named _timer a lot */  \
 968         "*_sht",      /* scsi also used *_sht to some extent */         \
 969         "*_ops",                                                        \
 970         "*_probe",                                                      \
 971         "*_probe_one",                                                  \
 972         "*_console"
 973
 974 static const char *const head_sections[] = { ".head.text*", NULL };
 975 static const char *const linker_symbols[] =
 976         { "__init_begin", "_sinittext", "_einittext", NULL };
 977 static const char *const optim_symbols[] = { "*.constprop.*", NULL };
 978
 979 enum mismatch {
 980         TEXT_TO_ANY_INIT,
 981         DATA_TO_ANY_INIT,
 982         TEXT_TO_ANY_EXIT,
 983         DATA_TO_ANY_EXIT,
 984         XXXINIT_TO_SOME_INIT,
 985         XXXEXIT_TO_SOME_EXIT,
 986         ANY_INIT_TO_ANY_EXIT,
 987         ANY_EXIT_TO_ANY_INIT,
 988         EXPORT_TO_INIT_EXIT,
 989         EXTABLE_TO_NON_TEXT,
 990 };
 991
 992 /**
 993  * Describe how to match sections on different criteria:
 994  *
 995  * @fromsec: Array of sections to be matched.
 996  *
 997  * @bad_tosec: Relocations applied to a section in @fromsec to a section in
 998  * this array is forbidden (black-list).  Can be empty.
 999  *
1000  * @good_tosec: Relocations applied to a section in @fromsec must be
1001  * targeting sections in this array (white-list).  Can be empty.
1002  *
1003  * @mismatch: Type of mismatch.
1004  *
1005  * @symbol_white_list: Do not match a relocation to a symbol in this list
1006  * even if it is targeting a section in @bad_to_sec.
1007  *
1008  * @handler: Specific handler to call when a match is found.  If NULL,
1009  * default_mismatch_handler() will be called.
1010  *
1011  */
1012 struct sectioncheck {
1013         const char *fromsec[20];
1014         const char *bad_tosec[20];
1015         const char *good_tosec[20];
1016         enum mismatch mismatch;
1017         const char *symbol_white_list[20];
1018         void (*handler)(const char *modname, struct elf_info *elf,
1019                         const struct sectioncheck* const mismatch,
1020                         Elf_Rela *r, Elf_Sym *sym, const char *fromsec);
1021
1022 };
1023
1024 static void extable_mismatch_handler(const char *modname, struct elf_info *elf,
1025                                      const struct sectioncheck* const mismatch,
1026                                      Elf_Rela *r, Elf_Sym *sym,
1027                                      const char *fromsec);
1028
1029 static const struct sectioncheck sectioncheck[] = {
1030 /* Do not reference init/exit code/data from
1031  * normal code and data
1032  */
1033 {
1034         .fromsec = { TEXT_SECTIONS, NULL },
1035         .bad_tosec = { ALL_INIT_SECTIONS, NULL },
1036         .mismatch = TEXT_TO_ANY_INIT,
1037         .symbol_white_list = { DEFAULT_SYMBOL_WHITE_LIST, NULL },
1038 },
1039 {
1040         .fromsec = { DATA_SECTIONS, NULL },
1041         .bad_tosec = { ALL_XXXINIT_SECTIONS, NULL },
1042         .mismatch = DATA_TO_ANY_INIT,
1043         .symbol_white_list = { DEFAULT_SYMBOL_WHITE_LIST, NULL },
1044 },
1045 {
1046         .fromsec = { DATA_SECTIONS, NULL },
1047         .bad_tosec = { INIT_SECTIONS, NULL },
1048         .mismatch = DATA_TO_ANY_INIT,
1049         .symbol_white_list = {
1050                 "*_template", "*_timer", "*_sht", "*_ops",
1051                 "*_probe", "*_probe_one", "*_console", NULL
1052         },
1053 },
1054 {
1055         .fromsec = { TEXT_SECTIONS, NULL },
1056         .bad_tosec = { ALL_EXIT_SECTIONS, NULL },
1057         .mismatch = TEXT_TO_ANY_EXIT,
1058         .symbol_white_list = { DEFAULT_SYMBOL_WHITE_LIST, NULL },
1059 },
1060 {
1061         .fromsec = { DATA_SECTIONS, NULL },
1062         .bad_tosec = { ALL_EXIT_SECTIONS, NULL },
1063         .mismatch = DATA_TO_ANY_EXIT,
1064         .symbol_white_list = { DEFAULT_SYMBOL_WHITE_LIST, NULL },
1065 },
1066 /* Do not reference init code/data from meminit code/data */
1067 {
1068         .fromsec = { ALL_XXXINIT_SECTIONS, NULL },
1069         .bad_tosec = { INIT_SECTIONS, NULL },
1070         .mismatch = XXXINIT_TO_SOME_INIT,
1071         .symbol_white_list = { DEFAULT_SYMBOL_WHITE_LIST, NULL },
1072 },
1073 /* Do not reference exit code/data from memexit code/data */
1074 {
1075         .fromsec = { ALL_XXXEXIT_SECTIONS, NULL },
1076         .bad_tosec = { EXIT_SECTIONS, NULL },
1077         .mismatch = XXXEXIT_TO_SOME_EXIT,
1078         .symbol_white_list = { DEFAULT_SYMBOL_WHITE_LIST, NULL },
1079 },
1080 /* Do not use exit code/data from init code */
1081 {
1082         .fromsec = { ALL_INIT_SECTIONS, NULL },
1083         .bad_tosec = { ALL_EXIT_SECTIONS, NULL },
1084         .mismatch = ANY_INIT_TO_ANY_EXIT,
1085         .symbol_white_list = { DEFAULT_SYMBOL_WHITE_LIST, NULL },
1086 },
1087 /* Do not use init code/data from exit code */
1088 {
1089         .fromsec = { ALL_EXIT_SECTIONS, NULL },
1090         .bad_tosec = { ALL_INIT_SECTIONS, NULL },
1091         .mismatch = ANY_EXIT_TO_ANY_INIT,
1092         .symbol_white_list = { DEFAULT_SYMBOL_WHITE_LIST, NULL },
1093 },
1094 {
1095         .fromsec = { ALL_PCI_INIT_SECTIONS, NULL },
1096         .bad_tosec = { INIT_SECTIONS, NULL },
1097         .mismatch = ANY_INIT_TO_ANY_EXIT,
1098         .symbol_white_list = { NULL },
1099 },
1100 /* Do not export init/exit functions or data */
1101 {
1102         .fromsec = { "__ksymtab*", NULL },
1103         .bad_tosec = { INIT_SECTIONS, EXIT_SECTIONS, NULL },
1104         .mismatch = EXPORT_TO_INIT_EXIT,
1105         .symbol_white_list = { DEFAULT_SYMBOL_WHITE_LIST, NULL },
1106 },
1107 {
1108         .fromsec = { "__ex_table", NULL },
1109         /* If you're adding any new black-listed sections in here, consider
1110          * adding a special 'printer' for them in scripts/check_extable.
1111          */
1112         .bad_tosec = { ".altinstr_replacement", NULL },
1113         .good_tosec = {ALL_TEXT_SECTIONS , NULL},
1114         .mismatch = EXTABLE_TO_NON_TEXT,
1115         .handler = extable_mismatch_handler,
1116 }
1117 };
1118
1119 static const struct sectioncheck *section_mismatch(
1120                 const char *fromsec, const char *tosec)
1121 {
1122         int i;
1123         int elems = sizeof(sectioncheck) / sizeof(struct sectioncheck);
1124         const struct sectioncheck *check = &sectioncheck[0];
1125
1126         /*
1127          * The target section could be the SHT_NUL section when we're
1128          * handling relocations to un-resolved symbols, trying to match it
1129          * doesn't make much sense and causes build failures on parisc
1130          * architectures.
1131          */
1132         if (*tosec == '\0')
1133                 return NULL;
1134
1135         for (i = 0; i < elems; i++) {
1136                 if (match(fromsec, check->fromsec)) {
1137                         if (check->bad_tosec[0] && match(tosec, check->bad_tosec))
1138                                 return check;
1139                         if (check->good_tosec[0] && !match(tosec, check->good_tosec))
1140                                 return check;
1141                 }
1142                 check++;
1143         }
1144         return NULL;
1145 }
1146
1147 /**
1148  * Whitelist to allow certain references to pass with no warning.
1149  *
1150  * Pattern 1:
1151  *   If a module parameter is declared __initdata and permissions=0
1152  *   then this is legal despite the warning generated.
1153  *   We cannot see value of permissions here, so just ignore
1154  *   this pattern.
1155  *   The pattern is identified by:
1156  *   tosec   = .init.data
1157  *   fromsec = .data*
1158  *   atsym   =__param*
1159  *
1160  * Pattern 1a:
1161  *   module_param_call() ops can refer to __init set function if permissions=0
1162  *   The pattern is identified by:
1163  *   tosec   = .init.text
1164  *   fromsec = .data*
1165  *   atsym   = __param_ops_*
1166  *
1167  * Pattern 2:
1168  *   Many drivers utilise a *driver container with references to
1169  *   add, remove, probe functions etc.
1170  *   the pattern is identified by:
1171  *   tosec   = init or exit section
1172  *   fromsec = data section
1173  *   atsym = *driver, *_template, *_sht, *_ops, *_probe,
1174  *           *probe_one, *_console, *_timer
1175  *
1176  * Pattern 3:
1177  *   Whitelist all references from .head.text to any init section
1178  *
1179  * Pattern 4:
1180  *   Some symbols belong to init section but still it is ok to reference
1181  *   these from non-init sections as these symbols don't have any memory
1182  *   allocated for them and symbol address and value are same. So even
1183  *   if init section is freed, its ok to reference those symbols.
1184  *   For ex. symbols marking the init section boundaries.
1185  *   This pattern is identified by
1186  *   refsymname = __init_begin, _sinittext, _einittext
1187  *
1188  * Pattern 5:
1189  *   GCC may optimize static inlines when fed constant arg(s) resulting
1190  *   in functions like cpumask_empty() -- generating an associated symbol
1191  *   cpumask_empty.constprop.3 that appears in the audit.  If the const that
1192  *   is passed in comes from __init, like say nmi_ipi_mask, we get a
1193  *   meaningless section warning.  May need to add isra symbols too...
1194  *   This pattern is identified by
1195  *   tosec   = init section
1196  *   fromsec = text section
1197  *   refsymname = *.constprop.*
1198  *
1199  * Pattern 6:
1200  *   Hide section mismatch warnings for ELF local symbols.  The goal
1201  *   is to eliminate false positive modpost warnings caused by
1202  *   compiler-generated ELF local symbol names such as ".LANCHOR1".
1203  *   Autogenerated symbol names bypass modpost's "Pattern 2"
1204  *   whitelisting, which relies on pattern-matching against symbol
1205  *   names to work.  (One situation where gcc can autogenerate ELF
1206  *   local symbols is when "-fsection-anchors" is used.)
1207  **/
1208 static int secref_whitelist(const struct sectioncheck *mismatch,
1209                             const char *fromsec, const char *fromsym,
1210                             const char *tosec, const char *tosym)
1211 {
1212         /* Check for pattern 1 */
1213         if (match(tosec, init_data_sections) &&
1214             match(fromsec, data_sections) &&
1215             strstarts(fromsym, "__param"))
1216                 return 0;
1217
1218         /* Check for pattern 1a */
1219         if (strcmp(tosec, ".init.text") == 0 &&
1220             match(fromsec, data_sections) &&
1221             strstarts(fromsym, "__param_ops_"))
1222                 return 0;
1223
1224         /* Check for pattern 2 */
1225         if (match(tosec, init_exit_sections) &&
1226             match(fromsec, data_sections) &&
1227             match(fromsym, mismatch->symbol_white_list))
1228                 return 0;
1229
1230         /* Check for pattern 3 */
1231         if (match(fromsec, head_sections) &&
1232             match(tosec, init_sections))
1233                 return 0;
1234
1235         /* Check for pattern 4 */
1236         if (match(tosym, linker_symbols))
1237                 return 0;
1238
1239         /* Check for pattern 5 */
1240         if (match(fromsec, text_sections) &&
1241             match(tosec, init_sections) &&
1242             match(fromsym, optim_symbols))
1243                 return 0;
1244
1245         /* Check for pattern 6 */
1246         if (strstarts(fromsym, ".L"))
1247                 return 0;
1248
1249         return 1;
1250 }
1251
1252 static inline int is_arm_mapping_symbol(const char *str)
1253 {
1254         return str[0] == '$' && strchr("axtd", str[1])
1255                && (str[2] == '\0' || str[2] == '.');
1256 }
1257
1258 /*
1259  * If there's no name there, ignore it; likewise, ignore it if it's
1260  * one of the magic symbols emitted used by current ARM tools.
1261  *
1262  * Otherwise if find_symbols_between() returns those symbols, they'll
1263  * fail the whitelist tests and cause lots of false alarms ... fixable
1264  * only by merging __exit and __init sections into __text, bloating
1265  * the kernel (which is especially evil on embedded platforms).
1266  */
1267 static inline int is_valid_name(struct elf_info *elf, Elf_Sym *sym)
1268 {
1269         const char *name = elf->strtab + sym->st_name;
1270
1271         if (!name || !strlen(name))
1272                 return 0;
1273         return !is_arm_mapping_symbol(name);
1274 }
1275
1276 /**
1277  * Find symbol based on relocation record info.
1278  * In some cases the symbol supplied is a valid symbol so
1279  * return refsym. If st_name != 0 we assume this is a valid symbol.
1280  * In other cases the symbol needs to be looked up in the symbol table
1281  * based on section and address.
1282  *  **/
1283 static Elf_Sym *find_elf_symbol(struct elf_info *elf, Elf64_Sword addr,
1284                                 Elf_Sym *relsym)
1285 {
1286         Elf_Sym *sym;
1287         Elf_Sym *near = NULL;
1288         Elf64_Sword distance = 20;
1289         Elf64_Sword d;
1290         unsigned int relsym_secindex;
1291
1292         if (relsym->st_name != 0)
1293                 return relsym;
1294
1295         relsym_secindex = get_secindex(elf, relsym);
1296         for (sym = elf->symtab_start; sym < elf->symtab_stop; sym++) {
1297                 if (get_secindex(elf, sym) != relsym_secindex)
1298                         continue;
1299                 if (ELF_ST_TYPE(sym->st_info) == STT_SECTION)
1300                         continue;
1301                 if (!is_valid_name(elf, sym))
1302                         continue;
1303                 if (sym->st_value == addr)
1304                         return sym;
1305                 /* Find a symbol nearby - addr are maybe negative */
1306                 d = sym->st_value - addr;
1307                 if (d < 0)
1308                         d = addr - sym->st_value;
1309                 if (d < distance) {
1310                         distance = d;
1311                         near = sym;
1312                 }
1313         }
1314         /* We need a close match */
1315         if (distance < 20)
1316                 return near;
1317         else
1318                 return NULL;
1319 }
1320
1321 /*
1322  * Find symbols before or equal addr and after addr - in the section sec.
1323  * If we find two symbols with equal offset prefer one with a valid name.
1324  * The ELF format may have a better way to detect what type of symbol
1325  * it is, but this works for now.
1326  **/
1327 static Elf_Sym *find_elf_symbol2(struct elf_info *elf, Elf_Addr addr,
1328                                  const char *sec)
1329 {
1330         Elf_Sym *sym;
1331         Elf_Sym *near = NULL;
1332         Elf_Addr distance = ~0;
1333
1334         for (sym = elf->symtab_start; sym < elf->symtab_stop; sym++) {
1335                 const char *symsec;
1336
1337                 if (is_shndx_special(sym->st_shndx))
1338                         continue;
1339                 symsec = sec_name(elf, get_secindex(elf, sym));
1340                 if (strcmp(symsec, sec) != 0)
1341                         continue;
1342                 if (!is_valid_name(elf, sym))
1343                         continue;
1344                 if (sym->st_value <= addr) {
1345                         if ((addr - sym->st_value) < distance) {
1346                                 distance = addr - sym->st_value;
1347                                 near = sym;
1348                         } else if ((addr - sym->st_value) == distance) {
1349                                 near = sym;
1350                         }
1351                 }
1352         }
1353         return near;
1354 }
1355
1356 /*
1357  * Convert a section name to the function/data attribute
1358  * .init.text => __init
1359  * .memexitconst => __memconst
1360  * etc.
1361  *
1362  * The memory of returned value has been allocated on a heap. The user of this
1363  * method should free it after usage.
1364 */
1365 static char *sec2annotation(const char *s)
1366 {
1367         if (match(s, init_exit_sections)) {
1368                 char *p = NOFAIL(malloc(20));
1369                 char *r = p;
1370
1371                 *p++ = '_';
1372                 *p++ = '_';
1373                 if (*s == '.')
1374                         s++;
1375                 while (*s && *s != '.')
1376                         *p++ = *s++;
1377                 *p = '\0';
1378                 if (*s == '.')
1379                         s++;
1380                 if (strstr(s, "rodata") != NULL)
1381                         strcat(p, "const ");
1382                 else if (strstr(s, "data") != NULL)
1383                         strcat(p, "data ");
1384                 else
1385                         strcat(p, " ");
1386                 return r;
1387         } else {
1388                 return NOFAIL(strdup(""));
1389         }
1390 }
1391
1392 static int is_function(Elf_Sym *sym)
1393 {
1394         if (sym)
1395                 return ELF_ST_TYPE(sym->st_info) == STT_FUNC;
1396         else
1397                 return -1;
1398 }
1399
1400 static void print_section_list(const char * const list[20])
1401 {
1402         const char *const *s = list;
1403
1404         while (*s) {
1405                 fprintf(stderr, "%s", *s);
1406                 s++;
1407                 if (*s)
1408                         fprintf(stderr, ", ");
1409         }
1410         fprintf(stderr, "\n");
1411 }
1412
1413 static inline void get_pretty_name(int is_func, const char** name, const char** name_p)
1414 {
1415         switch (is_func) {
1416         case 0: *name = "variable"; *name_p = ""; break;
1417         case 1: *name = "function"; *name_p = "()"; break;
1418         default: *name = "(unknown reference)"; *name_p = ""; break;
1419         }
1420 }
1421
1422 /*
1423  * Print a warning about a section mismatch.
1424  * Try to find symbols near it so user can find it.
1425  * Check whitelist before warning - it may be a false positive.
1426  */
1427 static void report_sec_mismatch(const char *modname,
1428                                 const struct sectioncheck *mismatch,
1429                                 const char *fromsec,
1430                                 unsigned long long fromaddr,
1431                                 const char *fromsym,
1432                                 int from_is_func,
1433                                 const char *tosec, const char *tosym,
1434                                 int to_is_func)
1435 {
1436         const char *from, *from_p;
1437         const char *to, *to_p;
1438         char *prl_from;
1439         char *prl_to;
1440
1441         sec_mismatch_count++;
1442
1443         get_pretty_name(from_is_func, &from, &from_p);
1444         get_pretty_name(to_is_func, &to, &to_p);
1445
1446         warn("%s(%s+0x%llx): Section mismatch in reference from the %s %s%s "
1447              "to the %s %s:%s%s\n",
1448              modname, fromsec, fromaddr, from, fromsym, from_p, to, tosec,
1449              tosym, to_p);
1450
1451         switch (mismatch->mismatch) {
1452         case TEXT_TO_ANY_INIT:
1453                 prl_from = sec2annotation(fromsec);
1454                 prl_to = sec2annotation(tosec);
1455                 fprintf(stderr,
1456                 "The function %s%s() references\n"
1457                 "the %s %s%s%s.\n"
1458                 "This is often because %s lacks a %s\n"
1459                 "annotation or the annotation of %s is wrong.\n",
1460                 prl_from, fromsym,
1461                 to, prl_to, tosym, to_p,
1462                 fromsym, prl_to, tosym);
1463                 free(prl_from);
1464                 free(prl_to);
1465                 break;
1466         case DATA_TO_ANY_INIT: {
1467                 prl_to = sec2annotation(tosec);
1468                 fprintf(stderr,
1469                 "The variable %s references\n"
1470                 "the %s %s%s%s\n"
1471                 "If the reference is valid then annotate the\n"
1472                 "variable with __init* or __refdata (see linux/init.h) "
1473                 "or name the variable:\n",
1474                 fromsym, to, prl_to, tosym, to_p);
1475                 print_section_list(mismatch->symbol_white_list);
1476                 free(prl_to);
1477                 break;
1478         }
1479         case TEXT_TO_ANY_EXIT:
1480                 prl_to = sec2annotation(tosec);
1481                 fprintf(stderr,
1482                 "The function %s() references a %s in an exit section.\n"
1483                 "Often the %s %s%s has valid usage outside the exit section\n"
1484                 "and the fix is to remove the %sannotation of %s.\n",
1485                 fromsym, to, to, tosym, to_p, prl_to, tosym);
1486                 free(prl_to);
1487                 break;
1488         case DATA_TO_ANY_EXIT: {
1489                 prl_to = sec2annotation(tosec);
1490                 fprintf(stderr,
1491                 "The variable %s references\n"
1492                 "the %s %s%s%s\n"
1493                 "If the reference is valid then annotate the\n"
1494                 "variable with __exit* (see linux/init.h) or "
1495                 "name the variable:\n",
1496                 fromsym, to, prl_to, tosym, to_p);
1497                 print_section_list(mismatch->symbol_white_list);
1498                 free(prl_to);
1499                 break;
1500         }
1501         case XXXINIT_TO_SOME_INIT:
1502         case XXXEXIT_TO_SOME_EXIT:
1503                 prl_from = sec2annotation(fromsec);
1504                 prl_to = sec2annotation(tosec);
1505                 fprintf(stderr,
1506                 "The %s %s%s%s references\n"
1507                 "a %s %s%s%s.\n"
1508                 "If %s is only used by %s then\n"
1509                 "annotate %s with a matching annotation.\n",
1510                 from, prl_from, fromsym, from_p,
1511                 to, prl_to, tosym, to_p,
1512                 tosym, fromsym, tosym);
1513                 free(prl_from);
1514                 free(prl_to);
1515                 break;
1516         case ANY_INIT_TO_ANY_EXIT:
1517                 prl_from = sec2annotation(fromsec);
1518                 prl_to = sec2annotation(tosec);
1519                 fprintf(stderr,
1520                 "The %s %s%s%s references\n"
1521                 "a %s %s%s%s.\n"
1522                 "This is often seen when error handling "
1523                 "in the init function\n"
1524                 "uses functionality in the exit path.\n"
1525                 "The fix is often to remove the %sannotation of\n"
1526                 "%s%s so it may be used outside an exit section.\n",
1527                 from, prl_from, fromsym, from_p,
1528                 to, prl_to, tosym, to_p,
1529                 prl_to, tosym, to_p);
1530                 free(prl_from);
1531                 free(prl_to);
1532                 break;
1533         case ANY_EXIT_TO_ANY_INIT:
1534                 prl_from = sec2annotation(fromsec);
1535                 prl_to = sec2annotation(tosec);
1536                 fprintf(stderr,
1537                 "The %s %s%s%s references\n"
1538                 "a %s %s%s%s.\n"
1539                 "This is often seen when error handling "
1540                 "in the exit function\n"
1541                 "uses functionality in the init path.\n"
1542                 "The fix is often to remove the %sannotation of\n"
1543                 "%s%s so it may be used outside an init section.\n",
1544                 from, prl_from, fromsym, from_p,
1545                 to, prl_to, tosym, to_p,
1546                 prl_to, tosym, to_p);
1547                 free(prl_from);
1548                 free(prl_to);
1549                 break;
1550         case EXPORT_TO_INIT_EXIT:
1551                 prl_to = sec2annotation(tosec);
1552                 fprintf(stderr,
1553                 "The symbol %s is exported and annotated %s\n"
1554                 "Fix this by removing the %sannotation of %s "
1555                 "or drop the export.\n",
1556                 tosym, prl_to, prl_to, tosym);
1557                 free(prl_to);
1558                 break;
1559         case EXTABLE_TO_NON_TEXT:
1560                 fatal("There's a special handler for this mismatch type, "
1561                       "we should never get here.");
1562                 break;
1563         }
1564         fprintf(stderr, "\n");
1565 }
1566
1567 static void default_mismatch_handler(const char *modname, struct elf_info *elf,
1568                                      const struct sectioncheck* const mismatch,
1569                                      Elf_Rela *r, Elf_Sym *sym, const char *fromsec)
1570 {
1571         const char *tosec;
1572         Elf_Sym *to;
1573         Elf_Sym *from;
1574         const char *tosym;
1575         const char *fromsym;
1576
1577         from = find_elf_symbol2(elf, r->r_offset, fromsec);
1578         fromsym = sym_name(elf, from);
1579
1580         if (strstarts(fromsym, "reference___initcall"))
1581                 return;
1582
1583         tosec = sec_name(elf, get_secindex(elf, sym));
1584         to = find_elf_symbol(elf, r->r_addend, sym);
1585         tosym = sym_name(elf, to);
1586
1587         /* check whitelist - we may ignore it */
1588         if (secref_whitelist(mismatch,
1589                              fromsec, fromsym, tosec, tosym)) {
1590                 report_sec_mismatch(modname, mismatch,
1591                                     fromsec, r->r_offset, fromsym,
1592                                     is_function(from), tosec, tosym,
1593                                     is_function(to));
1594         }
1595 }
1596
1597 static int is_executable_section(struct elf_info* elf, unsigned int section_index)
1598 {
1599         if (section_index > elf->num_sections)
1600                 fatal("section_index is outside elf->num_sections!\n");
1601
1602         return ((elf->sechdrs[section_index].sh_flags & SHF_EXECINSTR) == SHF_EXECINSTR);
1603 }
1604
1605 /*
1606  * We rely on a gross hack in section_rel[a]() calling find_extable_entry_size()
1607  * to know the sizeof(struct exception_table_entry) for the target architecture.
1608  */
1609 static unsigned int extable_entry_size = 0;
1610 static void find_extable_entry_size(const char* const sec, const Elf_Rela* r)
1611 {
1612         /*
1613          * If we're currently checking the second relocation within __ex_table,
1614          * that relocation offset tells us the offsetof(struct
1615          * exception_table_entry, fixup) which is equal to sizeof(struct
1616          * exception_table_entry) divided by two.  We use that to our advantage
1617          * since there's no portable way to get that size as every architecture
1618          * seems to go with different sized types.  Not pretty but better than
1619          * hard-coding the size for every architecture..
1620          */
1621         if (!extable_entry_size)
1622                 extable_entry_size = r->r_offset * 2;
1623 }
1624
1625 static inline bool is_extable_fault_address(Elf_Rela *r)
1626 {
1627         /*
1628          * extable_entry_size is only discovered after we've handled the
1629          * _second_ relocation in __ex_table, so only abort when we're not
1630          * handling the first reloc and extable_entry_size is zero.
1631          */
1632         if (r->r_offset && extable_entry_size == 0)
1633                 fatal("extable_entry size hasn't been discovered!\n");
1634
1635         return ((r->r_offset == 0) ||
1636                 (r->r_offset % extable_entry_size == 0));
1637 }
1638
1639 #define is_second_extable_reloc(Start, Cur, Sec)                        \
1640         (((Cur) == (Start) + 1) && (strcmp("__ex_table", (Sec)) == 0))
1641
1642 static void report_extable_warnings(const char* modname, struct elf_info* elf,
1643                                     const struct sectioncheck* const mismatch,
1644                                     Elf_Rela* r, Elf_Sym* sym,
1645                                     const char* fromsec, const char* tosec)
1646 {
1647         Elf_Sym* fromsym = find_elf_symbol2(elf, r->r_offset, fromsec);
1648         const char* fromsym_name = sym_name(elf, fromsym);
1649         Elf_Sym* tosym = find_elf_symbol(elf, r->r_addend, sym);
1650         const char* tosym_name = sym_name(elf, tosym);
1651         const char* from_pretty_name;
1652         const char* from_pretty_name_p;
1653         const char* to_pretty_name;
1654         const char* to_pretty_name_p;
1655
1656         get_pretty_name(is_function(fromsym),
1657                         &from_pretty_name, &from_pretty_name_p);
1658         get_pretty_name(is_function(tosym),
1659                         &to_pretty_name, &to_pretty_name_p);
1660
1661         warn("%s(%s+0x%lx): Section mismatch in reference"
1662              " from the %s %s%s to the %s %s:%s%s\n",
1663              modname, fromsec, (long)r->r_offset, from_pretty_name,
1664              fromsym_name, from_pretty_name_p,
1665              to_pretty_name, tosec, tosym_name, to_pretty_name_p);
1666
1667         if (!match(tosec, mismatch->bad_tosec) &&
1668             is_executable_section(elf, get_secindex(elf, sym)))
1669                 fprintf(stderr,
1670                         "The relocation at %s+0x%lx references\n"
1671                         "section \"%s\" which is not in the list of\n"
1672                         "authorized sections.  If you're adding a new section\n"
1673                         "and/or if this reference is valid, add \"%s\" to the\n"
1674                         "list of authorized sections to jump to on fault.\n"
1675                         "This can be achieved by adding \"%s\" to \n"
1676                         "OTHER_TEXT_SECTIONS in scripts/mod/modpost.c.\n",
1677                         fromsec, (long)r->r_offset, tosec, tosec, tosec);
1678 }
1679
1680 static void extable_mismatch_handler(const char* modname, struct elf_info *elf,
1681                                      const struct sectioncheck* const mismatch,
1682                                      Elf_Rela* r, Elf_Sym* sym,
1683                                      const char *fromsec)
1684 {
1685         const char* tosec = sec_name(elf, get_secindex(elf, sym));
1686
1687         sec_mismatch_count++;
1688
1689         report_extable_warnings(modname, elf, mismatch, r, sym, fromsec, tosec);
1690
1691         if (match(tosec, mismatch->bad_tosec))
1692                 fatal("The relocation at %s+0x%lx references\n"
1693                       "section \"%s\" which is black-listed.\n"
1694                       "Something is seriously wrong and should be fixed.\n"
1695                       "You might get more information about where this is\n"
1696                       "coming from by using scripts/check_extable.sh %s\n",
1697                       fromsec, (long)r->r_offset, tosec, modname);
1698         else if (!is_executable_section(elf, get_secindex(elf, sym))) {
1699                 if (is_extable_fault_address(r))
1700                         fatal("The relocation at %s+0x%lx references\n"
1701                               "section \"%s\" which is not executable, IOW\n"
1702                               "it is not possible for the kernel to fault\n"
1703                               "at that address.  Something is seriously wrong\n"
1704                               "and should be fixed.\n",
1705                               fromsec, (long)r->r_offset, tosec);
1706                 else
1707                         fatal("The relocation at %s+0x%lx references\n"
1708                               "section \"%s\" which is not executable, IOW\n"
1709                               "the kernel will fault if it ever tries to\n"
1710                               "jump to it.  Something is seriously wrong\n"
1711                               "and should be fixed.\n",
1712                               fromsec, (long)r->r_offset, tosec);
1713         }
1714 }
1715
1716 static void check_section_mismatch(const char *modname, struct elf_info *elf,
1717                                    Elf_Rela *r, Elf_Sym *sym, const char *fromsec)
1718 {
1719         const char *tosec = sec_name(elf, get_secindex(elf, sym));
1720         const struct sectioncheck *mismatch = section_mismatch(fromsec, tosec);
1721
1722         if (mismatch) {
1723                 if (mismatch->handler)
1724                         mismatch->handler(modname, elf,  mismatch,
1725                                           r, sym, fromsec);
1726                 else
1727                         default_mismatch_handler(modname, elf, mismatch,
1728                                                  r, sym, fromsec);
1729         }
1730 }
1731
1732 static unsigned int *reloc_location(struct elf_info *elf,
1733                                     Elf_Shdr *sechdr, Elf_Rela *r)
1734 {
1735         return sym_get_data_by_offset(elf, sechdr->sh_info, r->r_offset);
1736 }
1737
1738 static int addend_386_rel(struct elf_info *elf, Elf_Shdr *sechdr, Elf_Rela *r)
1739 {
1740         unsigned int r_typ = ELF_R_TYPE(r->r_info);
1741         unsigned int *location = reloc_location(elf, sechdr, r);
1742
1743         switch (r_typ) {
1744         case R_386_32:
1745                 r->r_addend = TO_NATIVE(*location);
1746                 break;
1747         case R_386_PC32:
1748                 r->r_addend = TO_NATIVE(*location) + 4;
1749                 /* For CONFIG_RELOCATABLE=y */
1750                 if (elf->hdr->e_type == ET_EXEC)
1751                         r->r_addend += r->r_offset;
1752                 break;
1753         }
1754         return 0;
1755 }
1756
1757 #ifndef R_ARM_CALL
1758 #define R_ARM_CALL      28
1759 #endif
1760 #ifndef R_ARM_JUMP24
1761 #define R_ARM_JUMP24    29
1762 #endif
1763
1764 #ifndef R_ARM_THM_CALL
1765 #define R_ARM_THM_CALL          10
1766 #endif
1767 #ifndef R_ARM_THM_JUMP24
1768 #define R_ARM_THM_JUMP24        30
1769 #endif
1770 #ifndef R_ARM_THM_JUMP19
1771 #define R_ARM_THM_JUMP19        51
1772 #endif
1773
1774 static int addend_arm_rel(struct elf_info *elf, Elf_Shdr *sechdr, Elf_Rela *r)
1775 {
1776         unsigned int r_typ = ELF_R_TYPE(r->r_info);
1777
1778         switch (r_typ) {
1779         case R_ARM_ABS32:
1780                 /* From ARM ABI: (S + A) | T */
1781                 r->r_addend = (int)(long)
1782                               (elf->symtab_start + ELF_R_SYM(r->r_info));
1783                 break;
1784         case R_ARM_PC24:
1785         case R_ARM_CALL:
1786         case R_ARM_JUMP24:
1787         case R_ARM_THM_CALL:
1788         case R_ARM_THM_JUMP24:
1789         case R_ARM_THM_JUMP19:
1790                 /* From ARM ABI: ((S + A) | T) - P */
1791                 r->r_addend = (int)(long)(elf->hdr +
1792                               sechdr->sh_offset +
1793                               (r->r_offset - sechdr->sh_addr));
1794                 break;
1795         default:
1796                 return 1;
1797         }
1798         return 0;
1799 }
1800
1801 static int addend_mips_rel(struct elf_info *elf, Elf_Shdr *sechdr, Elf_Rela *r)
1802 {
1803         unsigned int r_typ = ELF_R_TYPE(r->r_info);
1804         unsigned int *location = reloc_location(elf, sechdr, r);
1805         unsigned int inst;
1806
1807         if (r_typ == R_MIPS_HI16)
1808                 return 1;       /* skip this */
1809         inst = TO_NATIVE(*location);
1810         switch (r_typ) {
1811         case R_MIPS_LO16:
1812                 r->r_addend = inst & 0xffff;
1813                 break;
1814         case R_MIPS_26:
1815                 r->r_addend = (inst & 0x03ffffff) << 2;
1816                 break;
1817         case R_MIPS_32:
1818                 r->r_addend = inst;
1819                 break;
1820         }
1821         return 0;
1822 }
1823
1824 static void section_rela(const char *modname, struct elf_info *elf,
1825                          Elf_Shdr *sechdr)
1826 {
1827         Elf_Sym  *sym;
1828         Elf_Rela *rela;
1829         Elf_Rela r;
1830         unsigned int r_sym;
1831         const char *fromsec;
1832
1833         Elf_Rela *start = (void *)elf->hdr + sechdr->sh_offset;
1834         Elf_Rela *stop  = (void *)start + sechdr->sh_size;
1835
1836         fromsec = sech_name(elf, sechdr);
1837         fromsec += strlen(".rela");
1838         /* if from section (name) is know good then skip it */
1839         if (match(fromsec, section_white_list))
1840                 return;
1841
1842         for (rela = start; rela < stop; rela++) {
1843                 r.r_offset = TO_NATIVE(rela->r_offset);
1844 #if KERNEL_ELFCLASS == ELFCLASS64
1845                 if (elf->hdr->e_machine == EM_MIPS) {
1846                         unsigned int r_typ;
1847                         r_sym = ELF64_MIPS_R_SYM(rela->r_info);
1848                         r_sym = TO_NATIVE(r_sym);
1849                         r_typ = ELF64_MIPS_R_TYPE(rela->r_info);
1850                         r.r_info = ELF64_R_INFO(r_sym, r_typ);
1851                 } else {
1852                         r.r_info = TO_NATIVE(rela->r_info);
1853                         r_sym = ELF_R_SYM(r.r_info);
1854                 }
1855 #else
1856                 r.r_info = TO_NATIVE(rela->r_info);
1857                 r_sym = ELF_R_SYM(r.r_info);
1858 #endif
1859                 r.r_addend = TO_NATIVE(rela->r_addend);
1860                 sym = elf->symtab_start + r_sym;
1861                 /* Skip special sections */
1862                 if (is_shndx_special(sym->st_shndx))
1863                         continue;
1864                 if (is_second_extable_reloc(start, rela, fromsec))
1865                         find_extable_entry_size(fromsec, &r);
1866                 check_section_mismatch(modname, elf, &r, sym, fromsec);
1867         }
1868 }
1869
1870 static void section_rel(const char *modname, struct elf_info *elf,
1871                         Elf_Shdr *sechdr)
1872 {
1873         Elf_Sym *sym;
1874         Elf_Rel *rel;
1875         Elf_Rela r;
1876         unsigned int r_sym;
1877         const char *fromsec;
1878
1879         Elf_Rel *start = (void *)elf->hdr + sechdr->sh_offset;
1880         Elf_Rel *stop  = (void *)start + sechdr->sh_size;
1881
1882         fromsec = sech_name(elf, sechdr);
1883         fromsec += strlen(".rel");
1884         /* if from section (name) is know good then skip it */
1885         if (match(fromsec, section_white_list))
1886                 return;
1887
1888         for (rel = start; rel < stop; rel++) {
1889                 r.r_offset = TO_NATIVE(rel->r_offset);
1890 #if KERNEL_ELFCLASS == ELFCLASS64
1891                 if (elf->hdr->e_machine == EM_MIPS) {
1892                         unsigned int r_typ;
1893                         r_sym = ELF64_MIPS_R_SYM(rel->r_info);
1894                         r_sym = TO_NATIVE(r_sym);
1895                         r_typ = ELF64_MIPS_R_TYPE(rel->r_info);
1896                         r.r_info = ELF64_R_INFO(r_sym, r_typ);
1897                 } else {
1898                         r.r_info = TO_NATIVE(rel->r_info);
1899                         r_sym = ELF_R_SYM(r.r_info);
1900                 }
1901 #else
1902                 r.r_info = TO_NATIVE(rel->r_info);
1903                 r_sym = ELF_R_SYM(r.r_info);
1904 #endif
1905                 r.r_addend = 0;
1906                 switch (elf->hdr->e_machine) {
1907                 case EM_386:
1908                         if (addend_386_rel(elf, sechdr, &r))
1909                                 continue;
1910                         break;
1911                 case EM_ARM:
1912                         if (addend_arm_rel(elf, sechdr, &r))
1913                                 continue;
1914                         break;
1915                 case EM_MIPS:
1916                         if (addend_mips_rel(elf, sechdr, &r))
1917                                 continue;
1918                         break;
1919                 }
1920                 sym = elf->symtab_start + r_sym;
1921                 /* Skip special sections */
1922                 if (is_shndx_special(sym->st_shndx))
1923                         continue;
1924                 if (is_second_extable_reloc(start, rel, fromsec))
1925                         find_extable_entry_size(fromsec, &r);
1926                 check_section_mismatch(modname, elf, &r, sym, fromsec);
1927         }
1928 }
1929
1930 /**
1931  * A module includes a number of sections that are discarded
1932  * either when loaded or when used as built-in.
1933  * For loaded modules all functions marked __init and all data
1934  * marked __initdata will be discarded when the module has been initialized.
1935  * Likewise for modules used built-in the sections marked __exit
1936  * are discarded because __exit marked function are supposed to be called
1937  * only when a module is unloaded which never happens for built-in modules.
1938  * The check_sec_ref() function traverses all relocation records
1939  * to find all references to a section that reference a section that will
1940  * be discarded and warns about it.
1941  **/
1942 static void check_sec_ref(struct module *mod, const char *modname,
1943                           struct elf_info *elf)
1944 {
1945         int i;
1946         Elf_Shdr *sechdrs = elf->sechdrs;
1947
1948         /* Walk through all sections */
1949         for (i = 0; i < elf->num_sections; i++) {
1950                 check_section(modname, elf, &elf->sechdrs[i]);
1951                 /* We want to process only relocation sections and not .init */
1952                 if (sechdrs[i].sh_type == SHT_RELA)
1953                         section_rela(modname, elf, &elf->sechdrs[i]);
1954                 else if (sechdrs[i].sh_type == SHT_REL)
1955                         section_rel(modname, elf, &elf->sechdrs[i]);
1956         }
1957 }
1958
1959 static char *remove_dot(char *s)
1960 {
1961         size_t n = strcspn(s, ".");
1962
1963         if (n && s[n]) {
1964                 size_t m = strspn(s + n + 1, "0123456789");
1965                 if (m && (s[n + m] == '.' || s[n + m] == 0))
1966                         s[n] = 0;
1967
1968                 /* strip trailing .lto */
1969                 if (strends(s, ".lto"))
1970                         s[strlen(s) - 4] = '\0';
1971         }
1972         return s;
1973 }
1974
1975 static void read_symbols(const char *modname)
1976 {
1977         const char *symname;
1978         char *version;
1979         char *license;
1980         char *namespace;
1981         struct module *mod;
1982         struct elf_info info = { };
1983         Elf_Sym *sym;
1984
1985         if (!parse_elf(&info, modname))
1986                 return;
1987
1988         {
1989                 char *tmp;
1990
1991                 /* strip trailing .o */
1992                 tmp = NOFAIL(strdup(modname));
1993                 tmp[strlen(tmp) - 2] = '\0';
1994                 /* strip trailing .lto */
1995                 if (strends(tmp, ".lto"))
1996                         tmp[strlen(tmp) - 4] = '\0';
1997                 mod = new_module(tmp);
1998                 free(tmp);
1999         }
2000
2001         if (!mod->is_vmlinux) {
2002                 license = get_modinfo(&info, "license");
2003                 if (!license)
2004                         error("missing MODULE_LICENSE() in %s\n", modname);
2005                 while (license) {
2006                         if (license_is_gpl_compatible(license))
2007                                 mod->gpl_compatible = 1;
2008                         else {
2009                                 mod->gpl_compatible = 0;
2010                                 break;
2011                         }
2012                         license = get_next_modinfo(&info, "license", license);
2013                 }
2014
2015                 namespace = get_modinfo(&info, "import_ns");
2016                 while (namespace) {
2017                         add_namespace(&mod->imported_namespaces, namespace);
2018                         namespace = get_next_modinfo(&info, "import_ns",
2019                                                      namespace);
2020                 }
2021         }
2022
2023         for (sym = info.symtab_start; sym < info.symtab_stop; sym++) {
2024                 symname = remove_dot(info.strtab + sym->st_name);
2025
2026                 handle_symbol(mod, &info, sym, symname);
2027                 handle_moddevtable(mod, &info, sym, symname);
2028         }
2029
2030         for (sym = info.symtab_start; sym < info.symtab_stop; sym++) {
2031                 symname = remove_dot(info.strtab + sym->st_name);
2032
2033                 /* Apply symbol namespaces from __kstrtabns_<symbol> entries. */
2034                 if (strstarts(symname, "__kstrtabns_"))
2035                         sym_update_namespace(symname + strlen("__kstrtabns_"),
2036                                              namespace_from_kstrtabns(&info,
2037                                                                       sym));
2038
2039                 if (strstarts(symname, "__crc_"))
2040                         handle_modversion(mod, &info, sym,
2041                                           symname + strlen("__crc_"));
2042         }
2043
2044         // check for static EXPORT_SYMBOL_* functions && global vars
2045         for (sym = info.symtab_start; sym < info.symtab_stop; sym++) {
2046                 unsigned char bind = ELF_ST_BIND(sym->st_info);
2047
2048                 if (bind == STB_GLOBAL || bind == STB_WEAK) {
2049                         struct symbol *s =
2050                                 find_symbol(remove_dot(info.strtab +
2051                                                        sym->st_name));
2052
2053                         if (s)
2054                                 s->is_static = 0;
2055                 }
2056         }
2057
2058         check_sec_ref(mod, modname, &info);
2059
2060         if (!mod->is_vmlinux) {
2061                 version = get_modinfo(&info, "version");
2062                 if (version || all_versions)
2063                         get_src_version(modname, mod->srcversion,
2064                                         sizeof(mod->srcversion) - 1);
2065         }
2066
2067         parse_elf_finish(&info);
2068
2069         /* Our trick to get versioning for module struct etc. - it's
2070          * never passed as an argument to an exported function, so
2071          * the automatic versioning doesn't pick it up, but it's really
2072          * important anyhow */
2073         if (modversions)
2074                 mod->unres = alloc_symbol("module_layout", 0, mod->unres);
2075 }
2076
2077 static void read_symbols_from_files(const char *filename)
2078 {
2079         FILE *in = stdin;
2080         char fname[PATH_MAX];
2081
2082         if (strcmp(filename, "-") != 0) {
2083                 in = fopen(filename, "r");
2084                 if (!in)
2085                         fatal("Can't open filenames file %s: %m", filename);
2086         }
2087
2088         while (fgets(fname, PATH_MAX, in) != NULL) {
2089                 if (strends(fname, "\n"))
2090                         fname[strlen(fname)-1] = '\0';
2091                 read_symbols(fname);
2092         }
2093
2094         if (in != stdin)
2095                 fclose(in);
2096 }
2097
2098 #define SZ 500
2099
2100 /* We first write the generated file into memory using the
2101  * following helper, then compare to the file on disk and
2102  * only update the later if anything changed */
2103
2104 void __attribute__((format(printf, 2, 3))) buf_printf(struct buffer *buf,
2105                                                       const char *fmt, ...)
2106 {
2107         char tmp[SZ];
2108         int len;
2109         va_list ap;
2110
2111         va_start(ap, fmt);
2112         len = vsnprintf(tmp, SZ, fmt, ap);
2113         buf_write(buf, tmp, len);
2114         va_end(ap);
2115 }
2116
2117 void buf_write(struct buffer *buf, const char *s, int len)
2118 {
2119         if (buf->size - buf->pos < len) {
2120                 buf->size += len + SZ;
2121                 buf->p = NOFAIL(realloc(buf->p, buf->size));
2122         }
2123         strncpy(buf->p + buf->pos, s, len);
2124         buf->pos += len;
2125 }
2126
2127 static void check_for_gpl_usage(enum export exp, const char *m, const char *s)
2128 {
2129         switch (exp) {
2130         case export_gpl:
2131                 error("GPL-incompatible module %s.ko uses GPL-only symbol '%s'\n",
2132                       m, s);
2133                 break;
2134         case export_plain:
2135         case export_unknown:
2136                 /* ignore */
2137                 break;
2138         }
2139 }
2140
2141 static void check_exports(struct module *mod)
2142 {
2143         struct symbol *s, *exp;
2144
2145         for (s = mod->unres; s; s = s->next) {
2146                 const char *basename;
2147                 exp = find_symbol(s->name);
2148                 if (!exp || exp->module == mod) {
2149                         if (!s->weak && nr_unresolved++ < MAX_UNRESOLVED_REPORTS)
2150                                 modpost_log(warn_unresolved ? LOG_WARN : LOG_ERROR,
2151                                             "\"%s\" [%s.ko] undefined!\n",
2152                                             s->name, mod->name);
2153                         continue;
2154                 }
2155                 basename = strrchr(mod->name, '/');
2156                 if (basename)
2157                         basename++;
2158                 else
2159                         basename = mod->name;
2160
2161                 if (exp->namespace &&
2162                     !module_imports_namespace(mod, exp->namespace)) {
2163                         modpost_log(allow_missing_ns_imports ? LOG_WARN : LOG_ERROR,
2164                                     "module %s uses symbol %s from namespace %s, but does not import it.\n",
2165                                     basename, exp->name, exp->namespace);
2166                         add_namespace(&mod->missing_namespaces, exp->namespace);
2167                 }
2168
2169                 if (!mod->gpl_compatible)
2170                         check_for_gpl_usage(exp->export, basename, exp->name);
2171         }
2172 }
2173
2174 static void check_modname_len(struct module *mod)
2175 {
2176         const char *mod_name;
2177
2178         mod_name = strrchr(mod->name, '/');
2179         if (mod_name == NULL)
2180                 mod_name = mod->name;
2181         else
2182                 mod_name++;
2183         if (strlen(mod_name) >= MODULE_NAME_LEN)
2184                 error("module name is too long [%s.ko]\n", mod->name);
2185 }
2186
2187 /**
2188  * Header for the generated file
2189  **/
2190 static void add_header(struct buffer *b, struct module *mod)
2191 {
2192         buf_printf(b, "#include <linux/module.h>\n");
2193         /*
2194          * Include build-salt.h after module.h in order to
2195          * inherit the definitions.
2196          */
2197         buf_printf(b, "#define INCLUDE_VERMAGIC\n");
2198         buf_printf(b, "#include <linux/build-salt.h>\n");
2199         buf_printf(b, "#include <linux/elfnote-lto.h>\n");
2200         buf_printf(b, "#include <linux/vermagic.h>\n");
2201         buf_printf(b, "#include <linux/compiler.h>\n");
2202         buf_printf(b, "\n");
2203         buf_printf(b, "BUILD_SALT;\n");
2204         buf_printf(b, "BUILD_LTO_INFO;\n");
2205         buf_printf(b, "\n");
2206         buf_printf(b, "MODULE_INFO(vermagic, VERMAGIC_STRING);\n");
2207         buf_printf(b, "MODULE_INFO(name, KBUILD_MODNAME);\n");
2208         buf_printf(b, "\n");
2209         buf_printf(b, "__visible struct module __this_module\n");
2210         buf_printf(b, "__section(\".gnu.linkonce.this_module\") = {\n");
2211         buf_printf(b, "\t.name = KBUILD_MODNAME,\n");
2212         if (mod->has_init)
2213                 buf_printf(b, "\t.init = init_module,\n");
2214         if (mod->has_cleanup)
2215                 buf_printf(b, "#ifdef CONFIG_MODULE_UNLOAD\n"
2216                               "\t.exit = cleanup_module,\n"
2217                               "#endif\n");
2218         buf_printf(b, "\t.arch = MODULE_ARCH_INIT,\n");
2219         buf_printf(b, "};\n");
2220 }
2221
2222 static void add_intree_flag(struct buffer *b, int is_intree)
2223 {
2224         if (is_intree)
2225                 buf_printf(b, "\nMODULE_INFO(intree, \"Y\");\n");
2226 }
2227
2228 /* Cannot check for assembler */
2229 static void add_retpoline(struct buffer *b)
2230 {
2231         buf_printf(b, "\n#ifdef CONFIG_RETPOLINE\n");
2232         buf_printf(b, "MODULE_INFO(retpoline, \"Y\");\n");
2233         buf_printf(b, "#endif\n");
2234 }
2235
2236 static void add_staging_flag(struct buffer *b, const char *name)
2237 {
2238         if (strstarts(name, "drivers/staging"))
2239                 buf_printf(b, "\nMODULE_INFO(staging, \"Y\");\n");
2240 }
2241
2242 /**
2243  * Record CRCs for unresolved symbols
2244  **/
2245 static void add_versions(struct buffer *b, struct module *mod)
2246 {
2247         struct symbol *s, *exp;
2248
2249         for (s = mod->unres; s; s = s->next) {
2250                 exp = find_symbol(s->name);
2251                 if (!exp || exp->module == mod)
2252                         continue;
2253                 s->module = exp->module;
2254                 s->crc_valid = exp->crc_valid;
2255                 s->crc = exp->crc;
2256         }
2257
2258         if (!modversions)
2259                 return;
2260
2261         buf_printf(b, "\n");
2262         buf_printf(b, "static const struct modversion_info ____versions[]\n");
2263         buf_printf(b, "__used __section(\"__versions\") = {\n");
2264
2265         for (s = mod->unres; s; s = s->next) {
2266                 if (!s->module)
2267                         continue;
2268                 if (!s->crc_valid) {
2269                         warn("\"%s\" [%s.ko] has no CRC!\n",
2270                                 s->name, mod->name);
2271                         continue;
2272                 }
2273                 if (strlen(s->name) >= MODULE_NAME_LEN) {
2274                         error("too long symbol \"%s\" [%s.ko]\n",
2275                               s->name, mod->name);
2276                         break;
2277                 }
2278                 buf_printf(b, "\t{ %#8x, \"%s\" },\n",
2279                            s->crc, s->name);
2280         }
2281
2282         buf_printf(b, "};\n");
2283 }
2284
2285 static void add_depends(struct buffer *b, struct module *mod)
2286 {
2287         struct symbol *s;
2288         int first = 1;
2289
2290         /* Clear ->seen flag of modules that own symbols needed by this. */
2291         for (s = mod->unres; s; s = s->next)
2292                 if (s->module)
2293                         s->module->seen = s->module->is_vmlinux;
2294
2295         buf_printf(b, "\n");
2296         buf_printf(b, "MODULE_INFO(depends, \"");
2297         for (s = mod->unres; s; s = s->next) {
2298                 const char *p;
2299                 if (!s->module)
2300                         continue;
2301
2302                 if (s->module->seen)
2303                         continue;
2304
2305                 s->module->seen = 1;
2306                 p = strrchr(s->module->name, '/');
2307                 if (p)
2308                         p++;
2309                 else
2310                         p = s->module->name;
2311                 buf_printf(b, "%s%s", first ? "" : ",", p);
2312                 first = 0;
2313         }
2314         buf_printf(b, "\");\n");
2315 }
2316
2317 static void add_srcversion(struct buffer *b, struct module *mod)
2318 {
2319         if (mod->srcversion[0]) {
2320                 buf_printf(b, "\n");
2321                 buf_printf(b, "MODULE_INFO(srcversion, \"%s\");\n",
2322                            mod->srcversion);
2323         }
2324 }
2325
2326 static void write_buf(struct buffer *b, const char *fname)
2327 {
2328         FILE *file;
2329
2330         file = fopen(fname, "w");
2331         if (!file) {
2332                 perror(fname);
2333                 exit(1);
2334         }
2335         if (fwrite(b->p, 1, b->pos, file) != b->pos) {
2336                 perror(fname);
2337                 exit(1);
2338         }
2339         if (fclose(file) != 0) {
2340                 perror(fname);
2341                 exit(1);
2342         }
2343 }
2344
2345 static void write_if_changed(struct buffer *b, const char *fname)
2346 {
2347         char *tmp;
2348         FILE *file;
2349         struct stat st;
2350
2351         file = fopen(fname, "r");
2352         if (!file)
2353                 goto write;
2354
2355         if (fstat(fileno(file), &st) < 0)
2356                 goto close_write;
2357
2358         if (st.st_size != b->pos)
2359                 goto close_write;
2360
2361         tmp = NOFAIL(malloc(b->pos));
2362         if (fread(tmp, 1, b->pos, file) != b->pos)
2363                 goto free_write;
2364
2365         if (memcmp(tmp, b->p, b->pos) != 0)
2366                 goto free_write;
2367
2368         free(tmp);
2369         fclose(file);
2370         return;
2371
2372  free_write:
2373         free(tmp);
2374  close_write:
2375         fclose(file);
2376  write:
2377         write_buf(b, fname);
2378 }
2379
2380 /* parse Module.symvers file. line format:
2381  * 0x12345678<tab>symbol<tab>module<tab>export<tab>namespace
2382  **/
2383 static void read_dump(const char *fname)
2384 {
2385         char *buf, *pos, *line;
2386
2387         buf = read_text_file(fname);
2388         if (!buf)
2389                 /* No symbol versions, silently ignore */
2390                 return;
2391
2392         pos = buf;
2393
2394         while ((line = get_line(&pos))) {
2395                 char *symname, *namespace, *modname, *d, *export;
2396                 unsigned int crc;
2397                 struct module *mod;
2398                 struct symbol *s;
2399
2400                 if (!(symname = strchr(line, '\t')))
2401                         goto fail;
2402                 *symname++ = '\0';
2403                 if (!(modname = strchr(symname, '\t')))
2404                         goto fail;
2405                 *modname++ = '\0';
2406                 if (!(export = strchr(modname, '\t')))
2407                         goto fail;
2408                 *export++ = '\0';
2409                 if (!(namespace = strchr(export, '\t')))
2410                         goto fail;
2411                 *namespace++ = '\0';
2412
2413                 crc = strtoul(line, &d, 16);
2414                 if (*symname == '\0' || *modname == '\0' || *d != '\0')
2415                         goto fail;
2416                 mod = find_module(modname);
2417                 if (!mod) {
2418                         mod = new_module(modname);
2419                         mod->from_dump = 1;
2420                 }
2421                 s = sym_add_exported(symname, mod, export_no(export));
2422                 s->is_static = 0;
2423                 sym_set_crc(symname, crc);
2424                 sym_update_namespace(symname, namespace);
2425         }
2426         free(buf);
2427         return;
2428 fail:
2429         free(buf);
2430         fatal("parse error in symbol dump file\n");
2431 }
2432
2433 static void write_dump(const char *fname)
2434 {
2435         struct buffer buf = { };
2436         struct symbol *symbol;
2437         const char *namespace;
2438         int n;
2439
2440         for (n = 0; n < SYMBOL_HASH_SIZE ; n++) {
2441                 symbol = symbolhash[n];
2442                 while (symbol) {
2443                         if (!symbol->module->from_dump) {
2444                                 namespace = symbol->namespace;
2445                                 buf_printf(&buf, "0x%08x\t%s\t%s\t%s\t%s\n",
2446                                            symbol->crc, symbol->name,
2447                                            symbol->module->name,
2448                                            export_str(symbol->export),
2449                                            namespace ? namespace : "");
2450                         }
2451                         symbol = symbol->next;
2452                 }
2453         }
2454         write_buf(&buf, fname);
2455         free(buf.p);
2456 }
2457
2458 static void write_namespace_deps_files(const char *fname)
2459 {
2460         struct module *mod;
2461         struct namespace_list *ns;
2462         struct buffer ns_deps_buf = {};
2463
2464         for (mod = modules; mod; mod = mod->next) {
2465
2466                 if (mod->from_dump || !mod->missing_namespaces)
2467                         continue;
2468
2469                 buf_printf(&ns_deps_buf, "%s.ko:", mod->name);
2470
2471                 for (ns = mod->missing_namespaces; ns; ns = ns->next)
2472                         buf_printf(&ns_deps_buf, " %s", ns->namespace);
2473
2474                 buf_printf(&ns_deps_buf, "\n");
2475         }
2476
2477         write_if_changed(&ns_deps_buf, fname);
2478         free(ns_deps_buf.p);
2479 }
2480
2481 struct dump_list {
2482         struct dump_list *next;
2483         const char *file;
2484 };
2485
2486 int main(int argc, char **argv)
2487 {
2488         struct module *mod;
2489         struct buffer buf = { };
2490         char *missing_namespace_deps = NULL;
2491         char *dump_write = NULL, *files_source = NULL;
2492         int opt;
2493         int n;
2494         struct dump_list *dump_read_start = NULL;
2495         struct dump_list **dump_read_iter = &dump_read_start;
2496
2497         while ((opt = getopt(argc, argv, "ei:mnT:o:awENd:")) != -1) {
2498                 switch (opt) {
2499                 case 'e':
2500                         external_module = 1;
2501                         break;
2502                 case 'i':
2503                         *dump_read_iter =
2504                                 NOFAIL(calloc(1, sizeof(**dump_read_iter)));
2505                         (*dump_read_iter)->file = optarg;
2506                         dump_read_iter = &(*dump_read_iter)->next;
2507                         break;
2508                 case 'm':
2509                         modversions = 1;
2510                         break;
2511                 case 'n':
2512                         ignore_missing_files = 1;
2513                         break;
2514                 case 'o':
2515                         dump_write = optarg;
2516                         break;
2517                 case 'a':
2518                         all_versions = 1;
2519                         break;
2520                 case 'T':
2521                         files_source = optarg;
2522                         break;
2523                 case 'w':
2524                         warn_unresolved = 1;
2525                         break;
2526                 case 'E':
2527                         sec_mismatch_warn_only = false;
2528                         break;
2529                 case 'N':
2530                         allow_missing_ns_imports = 1;
2531                         break;
2532                 case 'd':
2533                         missing_namespace_deps = optarg;
2534                         break;
2535                 default:
2536                         exit(1);
2537                 }
2538         }
2539
2540         while (dump_read_start) {
2541                 struct dump_list *tmp;
2542
2543                 read_dump(dump_read_start->file);
2544                 tmp = dump_read_start->next;
2545                 free(dump_read_start);
2546                 dump_read_start = tmp;
2547         }
2548
2549         while (optind < argc)
2550                 read_symbols(argv[optind++]);
2551
2552         if (files_source)
2553                 read_symbols_from_files(files_source);
2554
2555         for (mod = modules; mod; mod = mod->next) {
2556                 char fname[PATH_MAX];
2557
2558                 if (mod->is_vmlinux || mod->from_dump)
2559                         continue;
2560
2561                 buf.pos = 0;
2562
2563                 check_modname_len(mod);
2564                 check_exports(mod);
2565
2566                 add_header(&buf, mod);
2567                 add_intree_flag(&buf, !external_module);
2568                 add_retpoline(&buf);
2569                 add_staging_flag(&buf, mod->name);
2570                 add_versions(&buf, mod);
2571                 add_depends(&buf, mod);
2572                 add_moddevtable(&buf, mod);
2573                 add_srcversion(&buf, mod);
2574
2575                 sprintf(fname, "%s.mod.c", mod->name);
2576                 write_if_changed(&buf, fname);
2577         }
2578
2579         if (missing_namespace_deps)
2580                 write_namespace_deps_files(missing_namespace_deps);
2581
2582         if (dump_write)
2583                 write_dump(dump_write);
2584         if (sec_mismatch_count && !sec_mismatch_warn_only)
2585                 error("Section mismatches detected.\n"
2586                       "Set CONFIG_SECTION_MISMATCH_WARN_ONLY=y to allow them.\n");
2587         for (n = 0; n < SYMBOL_HASH_SIZE; n++) {
2588                 struct symbol *s;
2589
2590                 for (s = symbolhash[n]; s; s = s->next) {
2591                         if (s->is_static)
2592                                 error("\"%s\" [%s] is a static %s\n",
2593                                       s->name, s->module->name,
2594                                       export_str(s->export));
2595                 }
2596         }
2597
2598         if (nr_unresolved > MAX_UNRESOLVED_REPORTS)
2599                 warn("suppressed %u unresolved symbol warnings because there were too many)\n",
2600                      nr_unresolved - MAX_UNRESOLVED_REPORTS);
2601
2602         free(buf.p);
2603
2604         return error_occurred ? 1 : 0;
2605 }