kernel/scripts/mod/modpost.c

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