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