scripts/mod/modpost.c

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