scripts/mod/modpost.c

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