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