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                 ".coldtext"
 891
 892 #define INIT_SECTIONS      ".init.*"
 893 #define MEM_INIT_SECTIONS  ".meminit.*"
 894
 895 #define EXIT_SECTIONS      ".exit.*"
 896 #define MEM_EXIT_SECTIONS  ".memexit.*"
 897
 898 #define ALL_TEXT_SECTIONS  ALL_INIT_TEXT_SECTIONS, ALL_EXIT_TEXT_SECTIONS, \
 899                 TEXT_SECTIONS, OTHER_TEXT_SECTIONS
 900
 901 /* init data sections */
 902 static const char *const init_data_sections[] =
 903         { ALL_INIT_DATA_SECTIONS, NULL };
 904
 905 /* all init sections */
 906 static const char *const init_sections[] = { ALL_INIT_SECTIONS, NULL };
 907
 908 /* All init and exit sections (code + data) */
 909 static const char *const init_exit_sections[] =
 910         {ALL_INIT_SECTIONS, ALL_EXIT_SECTIONS, NULL };
 911
 912 /* all text sections */
 913 static const char *const text_sections[] = { ALL_TEXT_SECTIONS, NULL };
 914
 915 /* data section */
 916 static const char *const data_sections[] = { DATA_SECTIONS, NULL };
 917
 918
 919 /* symbols in .data that may refer to init/exit sections */
 920 #define DEFAULT_SYMBOL_WHITE_LIST                                       \
 921         "*driver",                                                      \
 922         "*_template", /* scsi uses *_template a lot */                  \
 923         "*_timer",    /* arm uses ops structures named _timer a lot */  \
 924         "*_sht",      /* scsi also used *_sht to some extent */         \
 925         "*_ops",                                                        \
 926         "*_probe",                                                      \
 927         "*_probe_one",                                                  \
 928         "*_console"
 929
 930 static const char *const head_sections[] = { ".head.text*", NULL };
 931 static const char *const linker_symbols[] =
 932         { "__init_begin", "_sinittext", "_einittext", NULL };
 933 static const char *const optim_symbols[] = { "*.constprop.*", NULL };
 934
 935 enum mismatch {
 936         TEXT_TO_ANY_INIT,
 937         DATA_TO_ANY_INIT,
 938         TEXT_TO_ANY_EXIT,
 939         DATA_TO_ANY_EXIT,
 940         XXXINIT_TO_SOME_INIT,
 941         XXXEXIT_TO_SOME_EXIT,
 942         ANY_INIT_TO_ANY_EXIT,
 943         ANY_EXIT_TO_ANY_INIT,
 944         EXPORT_TO_INIT_EXIT,
 945         EXTABLE_TO_NON_TEXT,
 946 };
 947
 948 /**
 949  * Describe how to match sections on different criterias:
 950  *
 951  * @fromsec: Array of sections to be matched.
 952  *
 953  * @bad_tosec: Relocations applied to a section in @fromsec to a section in
 954  * this array is forbidden (black-list).  Can be empty.
 955  *
 956  * @good_tosec: Relocations applied to a section in @fromsec must be
 957  * targetting sections in this array (white-list).  Can be empty.
 958  *
 959  * @mismatch: Type of mismatch.
 960  *
 961  * @symbol_white_list: Do not match a relocation to a symbol in this list
 962  * even if it is targetting a section in @bad_to_sec.
 963  *
 964  * @handler: Specific handler to call when a match is found.  If NULL,
 965  * default_mismatch_handler() will be called.
 966  *
 967  */
 968 struct sectioncheck {
 969         const char *fromsec[20];
 970         const char *bad_tosec[20];
 971         const char *good_tosec[20];
 972         enum mismatch mismatch;
 973         const char *symbol_white_list[20];
 974         void (*handler)(const char *modname, struct elf_info *elf,
 975                         const struct sectioncheck* const mismatch,
 976                         Elf_Rela *r, Elf_Sym *sym, const char *fromsec);
 977
 978 };
 979
 980 static void extable_mismatch_handler(const char *modname, struct elf_info *elf,
 981                                      const struct sectioncheck* const mismatch,
 982                                      Elf_Rela *r, Elf_Sym *sym,
 983                                      const char *fromsec);
 984
 985 static const struct sectioncheck sectioncheck[] = {
 986 /* Do not reference init/exit code/data from
 987  * normal code and data
 988  */
 989 {
 990         .fromsec = { TEXT_SECTIONS, NULL },
 991         .bad_tosec = { ALL_INIT_SECTIONS, NULL },
 992         .mismatch = TEXT_TO_ANY_INIT,
 993         .symbol_white_list = { DEFAULT_SYMBOL_WHITE_LIST, NULL },
 994 },
 995 {
 996         .fromsec = { DATA_SECTIONS, NULL },
 997         .bad_tosec = { ALL_XXXINIT_SECTIONS, NULL },
 998         .mismatch = DATA_TO_ANY_INIT,
 999         .symbol_white_list = { DEFAULT_SYMBOL_WHITE_LIST, NULL },
1000 },
1001 {
1002         .fromsec = { DATA_SECTIONS, NULL },
1003         .bad_tosec = { INIT_SECTIONS, NULL },
1004         .mismatch = DATA_TO_ANY_INIT,
1005         .symbol_white_list = {
1006                 "*_template", "*_timer", "*_sht", "*_ops",
1007                 "*_probe", "*_probe_one", "*_console", NULL
1008         },
1009 },
1010 {
1011         .fromsec = { TEXT_SECTIONS, NULL },
1012         .bad_tosec = { ALL_EXIT_SECTIONS, NULL },
1013         .mismatch = TEXT_TO_ANY_EXIT,
1014         .symbol_white_list = { DEFAULT_SYMBOL_WHITE_LIST, NULL },
1015 },
1016 {
1017         .fromsec = { DATA_SECTIONS, NULL },
1018         .bad_tosec = { ALL_EXIT_SECTIONS, NULL },
1019         .mismatch = DATA_TO_ANY_EXIT,
1020         .symbol_white_list = { DEFAULT_SYMBOL_WHITE_LIST, NULL },
1021 },
1022 /* Do not reference init code/data from meminit code/data */
1023 {
1024         .fromsec = { ALL_XXXINIT_SECTIONS, NULL },
1025         .bad_tosec = { INIT_SECTIONS, NULL },
1026         .mismatch = XXXINIT_TO_SOME_INIT,
1027         .symbol_white_list = { DEFAULT_SYMBOL_WHITE_LIST, NULL },
1028 },
1029 /* Do not reference exit code/data from memexit code/data */
1030 {
1031         .fromsec = { ALL_XXXEXIT_SECTIONS, NULL },
1032         .bad_tosec = { EXIT_SECTIONS, NULL },
1033         .mismatch = XXXEXIT_TO_SOME_EXIT,
1034         .symbol_white_list = { DEFAULT_SYMBOL_WHITE_LIST, NULL },
1035 },
1036 /* Do not use exit code/data from init code */
1037 {
1038         .fromsec = { ALL_INIT_SECTIONS, NULL },
1039         .bad_tosec = { ALL_EXIT_SECTIONS, NULL },
1040         .mismatch = ANY_INIT_TO_ANY_EXIT,
1041         .symbol_white_list = { DEFAULT_SYMBOL_WHITE_LIST, NULL },
1042 },
1043 /* Do not use init code/data from exit code */
1044 {
1045         .fromsec = { ALL_EXIT_SECTIONS, NULL },
1046         .bad_tosec = { ALL_INIT_SECTIONS, NULL },
1047         .mismatch = ANY_EXIT_TO_ANY_INIT,
1048         .symbol_white_list = { DEFAULT_SYMBOL_WHITE_LIST, NULL },
1049 },
1050 {
1051         .fromsec = { ALL_PCI_INIT_SECTIONS, NULL },
1052         .bad_tosec = { INIT_SECTIONS, NULL },
1053         .mismatch = ANY_INIT_TO_ANY_EXIT,
1054         .symbol_white_list = { NULL },
1055 },
1056 /* Do not export init/exit functions or data */
1057 {
1058         .fromsec = { "__ksymtab*", NULL },
1059         .bad_tosec = { INIT_SECTIONS, EXIT_SECTIONS, NULL },
1060         .mismatch = EXPORT_TO_INIT_EXIT,
1061         .symbol_white_list = { DEFAULT_SYMBOL_WHITE_LIST, NULL },
1062 },
1063 {
1064         .fromsec = { "__ex_table", NULL },
1065         /* If you're adding any new black-listed sections in here, consider
1066          * adding a special 'printer' for them in scripts/check_extable.
1067          */
1068         .bad_tosec = { ".altinstr_replacement", NULL },
1069         .good_tosec = {ALL_TEXT_SECTIONS , NULL},
1070         .mismatch = EXTABLE_TO_NON_TEXT,
1071         .handler = extable_mismatch_handler,
1072 }
1073 };
1074
1075 static const struct sectioncheck *section_mismatch(
1076                 const char *fromsec, const char *tosec)
1077 {
1078         int i;
1079         int elems = sizeof(sectioncheck) / sizeof(struct sectioncheck);
1080         const struct sectioncheck *check = &sectioncheck[0];
1081
1082         /*
1083          * The target section could be the SHT_NUL section when we're
1084          * handling relocations to un-resolved symbols, trying to match it
1085          * doesn't make much sense and causes build failures on parisc and
1086          * mn10300 architectures.
1087          */
1088         if (*tosec == '\0')
1089                 return NULL;
1090
1091         for (i = 0; i < elems; i++) {
1092                 if (match(fromsec, check->fromsec)) {
1093                         if (check->bad_tosec[0] && match(tosec, check->bad_tosec))
1094                                 return check;
1095                         if (check->good_tosec[0] && !match(tosec, check->good_tosec))
1096                                 return check;
1097                 }
1098                 check++;
1099         }
1100         return NULL;
1101 }
1102
1103 /**
1104  * Whitelist to allow certain references to pass with no warning.
1105  *
1106  * Pattern 1:
1107  *   If a module parameter is declared __initdata and permissions=0
1108  *   then this is legal despite the warning generated.
1109  *   We cannot see value of permissions here, so just ignore
1110  *   this pattern.
1111  *   The pattern is identified by:
1112  *   tosec   = .init.data
1113  *   fromsec = .data*
1114  *   atsym   =__param*
1115  *
1116  * Pattern 1a:
1117  *   module_param_call() ops can refer to __init set function if permissions=0
1118  *   The pattern is identified by:
1119  *   tosec   = .init.text
1120  *   fromsec = .data*
1121  *   atsym   = __param_ops_*
1122  *
1123  * Pattern 2:
1124  *   Many drivers utilise a *driver container with references to
1125  *   add, remove, probe functions etc.
1126  *   the pattern is identified by:
1127  *   tosec   = init or exit section
1128  *   fromsec = data section
1129  *   atsym = *driver, *_template, *_sht, *_ops, *_probe,
1130  *           *probe_one, *_console, *_timer
1131  *
1132  * Pattern 3:
1133  *   Whitelist all references from .head.text to any init section
1134  *
1135  * Pattern 4:
1136  *   Some symbols belong to init section but still it is ok to reference
1137  *   these from non-init sections as these symbols don't have any memory
1138  *   allocated for them and symbol address and value are same. So even
1139  *   if init section is freed, its ok to reference those symbols.
1140  *   For ex. symbols marking the init section boundaries.
1141  *   This pattern is identified by
1142  *   refsymname = __init_begin, _sinittext, _einittext
1143  *
1144  * Pattern 5:
1145  *   GCC may optimize static inlines when fed constant arg(s) resulting
1146  *   in functions like cpumask_empty() -- generating an associated symbol
1147  *   cpumask_empty.constprop.3 that appears in the audit.  If the const that
1148  *   is passed in comes from __init, like say nmi_ipi_mask, we get a
1149  *   meaningless section warning.  May need to add isra symbols too...
1150  *   This pattern is identified by
1151  *   tosec   = init section
1152  *   fromsec = text section
1153  *   refsymname = *.constprop.*
1154  *
1155  **/
1156 static int secref_whitelist(const struct sectioncheck *mismatch,
1157                             const char *fromsec, const char *fromsym,
1158                             const char *tosec, const char *tosym)
1159 {
1160         /* Check for pattern 1 */
1161         if (match(tosec, init_data_sections) &&
1162             match(fromsec, data_sections) &&
1163             (strncmp(fromsym, "__param", strlen("__param")) == 0))
1164                 return 0;
1165
1166         /* Check for pattern 1a */
1167         if (strcmp(tosec, ".init.text") == 0 &&
1168             match(fromsec, data_sections) &&
1169             (strncmp(fromsym, "__param_ops_", strlen("__param_ops_")) == 0))
1170                 return 0;
1171
1172         /* Check for pattern 2 */
1173         if (match(tosec, init_exit_sections) &&
1174             match(fromsec, data_sections) &&
1175             match(fromsym, mismatch->symbol_white_list))
1176                 return 0;
1177
1178         /* Check for pattern 3 */
1179         if (match(fromsec, head_sections) &&
1180             match(tosec, init_sections))
1181                 return 0;
1182
1183         /* Check for pattern 4 */
1184         if (match(tosym, linker_symbols))
1185                 return 0;
1186
1187         /* Check for pattern 5 */
1188         if (match(fromsec, text_sections) &&
1189             match(tosec, init_sections) &&
1190             match(fromsym, optim_symbols))
1191                 return 0;
1192
1193         return 1;
1194 }
1195
1196 /**
1197  * Find symbol based on relocation record info.
1198  * In some cases the symbol supplied is a valid symbol so
1199  * return refsym. If st_name != 0 we assume this is a valid symbol.
1200  * In other cases the symbol needs to be looked up in the symbol table
1201  * based on section and address.
1202  *  **/
1203 static Elf_Sym *find_elf_symbol(struct elf_info *elf, Elf64_Sword addr,
1204                                 Elf_Sym *relsym)
1205 {
1206         Elf_Sym *sym;
1207         Elf_Sym *near = NULL;
1208         Elf64_Sword distance = 20;
1209         Elf64_Sword d;
1210         unsigned int relsym_secindex;
1211
1212         if (relsym->st_name != 0)
1213                 return relsym;
1214
1215         relsym_secindex = get_secindex(elf, relsym);
1216         for (sym = elf->symtab_start; sym < elf->symtab_stop; sym++) {
1217                 if (get_secindex(elf, sym) != relsym_secindex)
1218                         continue;
1219                 if (ELF_ST_TYPE(sym->st_info) == STT_SECTION)
1220                         continue;
1221                 if (sym->st_value == addr)
1222                         return sym;
1223                 /* Find a symbol nearby - addr are maybe negative */
1224                 d = sym->st_value - addr;
1225                 if (d < 0)
1226                         d = addr - sym->st_value;
1227                 if (d < distance) {
1228                         distance = d;
1229                         near = sym;
1230                 }
1231         }
1232         /* We need a close match */
1233         if (distance < 20)
1234                 return near;
1235         else
1236                 return NULL;
1237 }
1238
1239 static inline int is_arm_mapping_symbol(const char *str)
1240 {
1241         return str[0] == '$' && strchr("axtd", str[1])
1242                && (str[2] == '\0' || str[2] == '.');
1243 }
1244
1245 /*
1246  * If there's no name there, ignore it; likewise, ignore it if it's
1247  * one of the magic symbols emitted used by current ARM tools.
1248  *
1249  * Otherwise if find_symbols_between() returns those symbols, they'll
1250  * fail the whitelist tests and cause lots of false alarms ... fixable
1251  * only by merging __exit and __init sections into __text, bloating
1252  * the kernel (which is especially evil on embedded platforms).
1253  */
1254 static inline int is_valid_name(struct elf_info *elf, Elf_Sym *sym)
1255 {
1256         const char *name = elf->strtab + sym->st_name;
1257
1258         if (!name || !strlen(name))
1259                 return 0;
1260         return !is_arm_mapping_symbol(name);
1261 }
1262
1263 /*
1264  * Find symbols before or equal addr and after addr - in the section sec.
1265  * If we find two symbols with equal offset prefer one with a valid name.
1266  * The ELF format may have a better way to detect what type of symbol
1267  * it is, but this works for now.
1268  **/
1269 static Elf_Sym *find_elf_symbol2(struct elf_info *elf, Elf_Addr addr,
1270                                  const char *sec)
1271 {
1272         Elf_Sym *sym;
1273         Elf_Sym *near = NULL;
1274         Elf_Addr distance = ~0;
1275
1276         for (sym = elf->symtab_start; sym < elf->symtab_stop; sym++) {
1277                 const char *symsec;
1278
1279                 if (is_shndx_special(sym->st_shndx))
1280                         continue;
1281                 symsec = sec_name(elf, get_secindex(elf, sym));
1282                 if (strcmp(symsec, sec) != 0)
1283                         continue;
1284                 if (!is_valid_name(elf, sym))
1285                         continue;
1286                 if (sym->st_value <= addr) {
1287                         if ((addr - sym->st_value) < distance) {
1288                                 distance = addr - sym->st_value;
1289                                 near = sym;
1290                         } else if ((addr - sym->st_value) == distance) {
1291                                 near = sym;
1292                         }
1293                 }
1294         }
1295         return near;
1296 }
1297
1298 /*
1299  * Convert a section name to the function/data attribute
1300  * .init.text => __init
1301  * .memexitconst => __memconst
1302  * etc.
1303  *
1304  * The memory of returned value has been allocated on a heap. The user of this
1305  * method should free it after usage.
1306 */
1307 static char *sec2annotation(const char *s)
1308 {
1309         if (match(s, init_exit_sections)) {
1310                 char *p = malloc(20);
1311                 char *r = p;
1312
1313                 *p++ = '_';
1314                 *p++ = '_';
1315                 if (*s == '.')
1316                         s++;
1317                 while (*s && *s != '.')
1318                         *p++ = *s++;
1319                 *p = '\0';
1320                 if (*s == '.')
1321                         s++;
1322                 if (strstr(s, "rodata") != NULL)
1323                         strcat(p, "const ");
1324                 else if (strstr(s, "data") != NULL)
1325                         strcat(p, "data ");
1326                 else
1327                         strcat(p, " ");
1328                 return r;
1329         } else {
1330                 return strdup("");
1331         }
1332 }
1333
1334 static int is_function(Elf_Sym *sym)
1335 {
1336         if (sym)
1337                 return ELF_ST_TYPE(sym->st_info) == STT_FUNC;
1338         else
1339                 return -1;
1340 }
1341
1342 static void print_section_list(const char * const list[20])
1343 {
1344         const char *const *s = list;
1345
1346         while (*s) {
1347                 fprintf(stderr, "%s", *s);
1348                 s++;
1349                 if (*s)
1350                         fprintf(stderr, ", ");
1351         }
1352         fprintf(stderr, "\n");
1353 }
1354
1355 static inline void get_pretty_name(int is_func, const char** name, const char** name_p)
1356 {
1357         switch (is_func) {
1358         case 0: *name = "variable"; *name_p = ""; break;
1359         case 1: *name = "function"; *name_p = "()"; break;
1360         default: *name = "(unknown reference)"; *name_p = ""; break;
1361         }
1362 }
1363
1364 /*
1365  * Print a warning about a section mismatch.
1366  * Try to find symbols near it so user can find it.
1367  * Check whitelist before warning - it may be a false positive.
1368  */
1369 static void report_sec_mismatch(const char *modname,
1370                                 const struct sectioncheck *mismatch,
1371                                 const char *fromsec,
1372                                 unsigned long long fromaddr,
1373                                 const char *fromsym,
1374                                 int from_is_func,
1375                                 const char *tosec, const char *tosym,
1376                                 int to_is_func)
1377 {
1378         const char *from, *from_p;
1379         const char *to, *to_p;
1380         char *prl_from;
1381         char *prl_to;
1382
1383         sec_mismatch_count++;
1384         if (!sec_mismatch_verbose)
1385                 return;
1386
1387         get_pretty_name(from_is_func, &from, &from_p);
1388         get_pretty_name(to_is_func, &to, &to_p);
1389
1390         warn("%s(%s+0x%llx): Section mismatch in reference from the %s %s%s "
1391              "to the %s %s:%s%s\n",
1392              modname, fromsec, fromaddr, from, fromsym, from_p, to, tosec,
1393              tosym, to_p);
1394
1395         switch (mismatch->mismatch) {
1396         case TEXT_TO_ANY_INIT:
1397                 prl_from = sec2annotation(fromsec);
1398                 prl_to = sec2annotation(tosec);
1399                 fprintf(stderr,
1400                 "The function %s%s() references\n"
1401                 "the %s %s%s%s.\n"
1402                 "This is often because %s lacks a %s\n"
1403                 "annotation or the annotation of %s is wrong.\n",
1404                 prl_from, fromsym,
1405                 to, prl_to, tosym, to_p,
1406                 fromsym, prl_to, tosym);
1407                 free(prl_from);
1408                 free(prl_to);
1409                 break;
1410         case DATA_TO_ANY_INIT: {
1411                 prl_to = sec2annotation(tosec);
1412                 fprintf(stderr,
1413                 "The variable %s references\n"
1414                 "the %s %s%s%s\n"
1415                 "If the reference is valid then annotate the\n"
1416                 "variable with __init* or __refdata (see linux/init.h) "
1417                 "or name the variable:\n",
1418                 fromsym, to, prl_to, tosym, to_p);
1419                 print_section_list(mismatch->symbol_white_list);
1420                 free(prl_to);
1421                 break;
1422         }
1423         case TEXT_TO_ANY_EXIT:
1424                 prl_to = sec2annotation(tosec);
1425                 fprintf(stderr,
1426                 "The function %s() references a %s in an exit section.\n"
1427                 "Often the %s %s%s has valid usage outside the exit section\n"
1428                 "and the fix is to remove the %sannotation of %s.\n",
1429                 fromsym, to, to, tosym, to_p, prl_to, tosym);
1430                 free(prl_to);
1431                 break;
1432         case DATA_TO_ANY_EXIT: {
1433                 prl_to = sec2annotation(tosec);
1434                 fprintf(stderr,
1435                 "The variable %s references\n"
1436                 "the %s %s%s%s\n"
1437                 "If the reference is valid then annotate the\n"
1438                 "variable with __exit* (see linux/init.h) or "
1439                 "name the variable:\n",
1440                 fromsym, to, prl_to, tosym, to_p);
1441                 print_section_list(mismatch->symbol_white_list);
1442                 free(prl_to);
1443                 break;
1444         }
1445         case XXXINIT_TO_SOME_INIT:
1446         case XXXEXIT_TO_SOME_EXIT:
1447                 prl_from = sec2annotation(fromsec);
1448                 prl_to = sec2annotation(tosec);
1449                 fprintf(stderr,
1450                 "The %s %s%s%s references\n"
1451                 "a %s %s%s%s.\n"
1452                 "If %s is only used by %s then\n"
1453                 "annotate %s with a matching annotation.\n",
1454                 from, prl_from, fromsym, from_p,
1455                 to, prl_to, tosym, to_p,
1456                 tosym, fromsym, tosym);
1457                 free(prl_from);
1458                 free(prl_to);
1459                 break;
1460         case ANY_INIT_TO_ANY_EXIT:
1461                 prl_from = sec2annotation(fromsec);
1462                 prl_to = sec2annotation(tosec);
1463                 fprintf(stderr,
1464                 "The %s %s%s%s references\n"
1465                 "a %s %s%s%s.\n"
1466                 "This is often seen when error handling "
1467                 "in the init function\n"
1468                 "uses functionality in the exit path.\n"
1469                 "The fix is often to remove the %sannotation of\n"
1470                 "%s%s so it may be used outside an exit section.\n",
1471                 from, prl_from, fromsym, from_p,
1472                 to, prl_to, tosym, to_p,
1473                 prl_to, tosym, to_p);
1474                 free(prl_from);
1475                 free(prl_to);
1476                 break;
1477         case ANY_EXIT_TO_ANY_INIT:
1478                 prl_from = sec2annotation(fromsec);
1479                 prl_to = sec2annotation(tosec);
1480                 fprintf(stderr,
1481                 "The %s %s%s%s references\n"
1482                 "a %s %s%s%s.\n"
1483                 "This is often seen when error handling "
1484                 "in the exit function\n"
1485                 "uses functionality in the init path.\n"
1486                 "The fix is often to remove the %sannotation of\n"
1487                 "%s%s so it may be used outside an init section.\n",
1488                 from, prl_from, fromsym, from_p,
1489                 to, prl_to, tosym, to_p,
1490                 prl_to, tosym, to_p);
1491                 free(prl_from);
1492                 free(prl_to);
1493                 break;
1494         case EXPORT_TO_INIT_EXIT:
1495                 prl_to = sec2annotation(tosec);
1496                 fprintf(stderr,
1497                 "The symbol %s is exported and annotated %s\n"
1498                 "Fix this by removing the %sannotation of %s "
1499                 "or drop the export.\n",
1500                 tosym, prl_to, prl_to, tosym);
1501                 free(prl_to);
1502                 break;
1503         case EXTABLE_TO_NON_TEXT:
1504                 fatal("There's a special handler for this mismatch type, "
1505                       "we should never get here.");
1506                 break;
1507         }
1508         fprintf(stderr, "\n");
1509 }
1510
1511 static void default_mismatch_handler(const char *modname, struct elf_info *elf,
1512                                      const struct sectioncheck* const mismatch,
1513                                      Elf_Rela *r, Elf_Sym *sym, const char *fromsec)
1514 {
1515         const char *tosec;
1516         Elf_Sym *to;
1517         Elf_Sym *from;
1518         const char *tosym;
1519         const char *fromsym;
1520
1521         from = find_elf_symbol2(elf, r->r_offset, fromsec);
1522         fromsym = sym_name(elf, from);
1523
1524         if (!strncmp(fromsym, "reference___initcall",
1525                      sizeof("reference___initcall")-1))
1526                 return;
1527
1528         tosec = sec_name(elf, get_secindex(elf, sym));
1529         to = find_elf_symbol(elf, r->r_addend, sym);
1530         tosym = sym_name(elf, to);
1531
1532         /* check whitelist - we may ignore it */
1533         if (secref_whitelist(mismatch,
1534                              fromsec, fromsym, tosec, tosym)) {
1535                 report_sec_mismatch(modname, mismatch,
1536                                     fromsec, r->r_offset, fromsym,
1537                                     is_function(from), tosec, tosym,
1538                                     is_function(to));
1539         }
1540 }
1541
1542 static int is_executable_section(struct elf_info* elf, unsigned int section_index)
1543 {
1544         if (section_index > elf->num_sections)
1545                 fatal("section_index is outside elf->num_sections!\n");
1546
1547         return ((elf->sechdrs[section_index].sh_flags & SHF_EXECINSTR) == SHF_EXECINSTR);
1548 }
1549
1550 /*
1551  * We rely on a gross hack in section_rel[a]() calling find_extable_entry_size()
1552  * to know the sizeof(struct exception_table_entry) for the target architecture.
1553  */
1554 static unsigned int extable_entry_size = 0;
1555 static void find_extable_entry_size(const char* const sec, const Elf_Rela* r)
1556 {
1557         /*
1558          * If we're currently checking the second relocation within __ex_table,
1559          * that relocation offset tells us the offsetof(struct
1560          * exception_table_entry, fixup) which is equal to sizeof(struct
1561          * exception_table_entry) divided by two.  We use that to our advantage
1562          * since there's no portable way to get that size as every architecture
1563          * seems to go with different sized types.  Not pretty but better than
1564          * hard-coding the size for every architecture..
1565          */
1566         if (!extable_entry_size)
1567                 extable_entry_size = r->r_offset * 2;
1568 }
1569
1570 static inline bool is_extable_fault_address(Elf_Rela *r)
1571 {
1572         /*
1573          * extable_entry_size is only discovered after we've handled the
1574          * _second_ relocation in __ex_table, so only abort when we're not
1575          * handling the first reloc and extable_entry_size is zero.
1576          */
1577         if (r->r_offset && extable_entry_size == 0)
1578                 fatal("extable_entry size hasn't been discovered!\n");
1579
1580         return ((r->r_offset == 0) ||
1581                 (r->r_offset % extable_entry_size == 0));
1582 }
1583
1584 #define is_second_extable_reloc(Start, Cur, Sec)                        \
1585         (((Cur) == (Start) + 1) && (strcmp("__ex_table", (Sec)) == 0))
1586
1587 static void report_extable_warnings(const char* modname, struct elf_info* elf,
1588                                     const struct sectioncheck* const mismatch,
1589                                     Elf_Rela* r, Elf_Sym* sym,
1590                                     const char* fromsec, const char* tosec)
1591 {
1592         Elf_Sym* fromsym = find_elf_symbol2(elf, r->r_offset, fromsec);
1593         const char* fromsym_name = sym_name(elf, fromsym);
1594         Elf_Sym* tosym = find_elf_symbol(elf, r->r_addend, sym);
1595         const char* tosym_name = sym_name(elf, tosym);
1596         const char* from_pretty_name;
1597         const char* from_pretty_name_p;
1598         const char* to_pretty_name;
1599         const char* to_pretty_name_p;
1600
1601         get_pretty_name(is_function(fromsym),
1602                         &from_pretty_name, &from_pretty_name_p);
1603         get_pretty_name(is_function(tosym),
1604                         &to_pretty_name, &to_pretty_name_p);
1605
1606         warn("%s(%s+0x%lx): Section mismatch in reference"
1607              " from the %s %s%s to the %s %s:%s%s\n",
1608              modname, fromsec, (long)r->r_offset, from_pretty_name,
1609              fromsym_name, from_pretty_name_p,
1610              to_pretty_name, tosec, tosym_name, to_pretty_name_p);
1611
1612         if (!match(tosec, mismatch->bad_tosec) &&
1613             is_executable_section(elf, get_secindex(elf, sym)))
1614                 fprintf(stderr,
1615                         "The relocation at %s+0x%lx references\n"
1616                         "section \"%s\" which is not in the list of\n"
1617                         "authorized sections.  If you're adding a new section\n"
1618                         "and/or if this reference is valid, add \"%s\" to the\n"
1619                         "list of authorized sections to jump to on fault.\n"
1620                         "This can be achieved by adding \"%s\" to \n"
1621                         "OTHER_TEXT_SECTIONS in scripts/mod/modpost.c.\n",
1622                         fromsec, (long)r->r_offset, tosec, tosec, tosec);
1623 }
1624
1625 static void extable_mismatch_handler(const char* modname, struct elf_info *elf,
1626                                      const struct sectioncheck* const mismatch,
1627                                      Elf_Rela* r, Elf_Sym* sym,
1628                                      const char *fromsec)
1629 {
1630         const char* tosec = sec_name(elf, get_secindex(elf, sym));
1631
1632         sec_mismatch_count++;
1633
1634         if (sec_mismatch_verbose)
1635                 report_extable_warnings(modname, elf, mismatch, r, sym,
1636                                         fromsec, tosec);
1637
1638         if (match(tosec, mismatch->bad_tosec))
1639                 fatal("The relocation at %s+0x%lx references\n"
1640                       "section \"%s\" which is black-listed.\n"
1641                       "Something is seriously wrong and should be fixed.\n"
1642                       "You might get more information about where this is\n"
1643                       "coming from by using scripts/check_extable.sh %s\n",
1644                       fromsec, (long)r->r_offset, tosec, modname);
1645         else if (!is_executable_section(elf, get_secindex(elf, sym))) {
1646                 if (is_extable_fault_address(r))
1647                         fatal("The relocation at %s+0x%lx references\n"
1648                               "section \"%s\" which is not executable, IOW\n"
1649                               "it is not possible for the kernel to fault\n"
1650                               "at that address.  Something is seriously wrong\n"
1651                               "and should be fixed.\n",
1652                               fromsec, (long)r->r_offset, tosec);
1653                 else
1654                         fatal("The relocation at %s+0x%lx references\n"
1655                               "section \"%s\" which is not executable, IOW\n"
1656                               "the kernel will fault if it ever tries to\n"
1657                               "jump to it.  Something is seriously wrong\n"
1658                               "and should be fixed.\n",
1659                               fromsec, (long)r->r_offset, tosec);
1660         }
1661 }
1662
1663 static void check_section_mismatch(const char *modname, struct elf_info *elf,
1664                                    Elf_Rela *r, Elf_Sym *sym, const char *fromsec)
1665 {
1666         const char *tosec = sec_name(elf, get_secindex(elf, sym));;
1667         const struct sectioncheck *mismatch = section_mismatch(fromsec, tosec);
1668
1669         if (mismatch) {
1670                 if (mismatch->handler)
1671                         mismatch->handler(modname, elf,  mismatch,
1672                                           r, sym, fromsec);
1673                 else
1674                         default_mismatch_handler(modname, elf, mismatch,
1675                                                  r, sym, fromsec);
1676         }
1677 }
1678
1679 static unsigned int *reloc_location(struct elf_info *elf,
1680                                     Elf_Shdr *sechdr, Elf_Rela *r)
1681 {
1682         Elf_Shdr *sechdrs = elf->sechdrs;
1683         int section = sechdr->sh_info;
1684
1685         return (void *)elf->hdr + sechdrs[section].sh_offset +
1686                 r->r_offset;
1687 }
1688
1689 static int addend_386_rel(struct elf_info *elf, Elf_Shdr *sechdr, Elf_Rela *r)
1690 {
1691         unsigned int r_typ = ELF_R_TYPE(r->r_info);
1692         unsigned int *location = reloc_location(elf, sechdr, r);
1693
1694         switch (r_typ) {
1695         case R_386_32:
1696                 r->r_addend = TO_NATIVE(*location);
1697                 break;
1698         case R_386_PC32:
1699                 r->r_addend = TO_NATIVE(*location) + 4;
1700                 /* For CONFIG_RELOCATABLE=y */
1701                 if (elf->hdr->e_type == ET_EXEC)
1702                         r->r_addend += r->r_offset;
1703                 break;
1704         }
1705         return 0;
1706 }
1707
1708 #ifndef R_ARM_CALL
1709 #define R_ARM_CALL      28
1710 #endif
1711 #ifndef R_ARM_JUMP24
1712 #define R_ARM_JUMP24    29
1713 #endif
1714
1715 #ifndef R_ARM_THM_CALL
1716 #define R_ARM_THM_CALL          10
1717 #endif
1718 #ifndef R_ARM_THM_JUMP24
1719 #define R_ARM_THM_JUMP24        30
1720 #endif
1721 #ifndef R_ARM_THM_JUMP19
1722 #define R_ARM_THM_JUMP19        51
1723 #endif
1724
1725 static int addend_arm_rel(struct elf_info *elf, Elf_Shdr *sechdr, Elf_Rela *r)
1726 {
1727         unsigned int r_typ = ELF_R_TYPE(r->r_info);
1728
1729         switch (r_typ) {
1730         case R_ARM_ABS32:
1731                 /* From ARM ABI: (S + A) | T */
1732                 r->r_addend = (int)(long)
1733                               (elf->symtab_start + ELF_R_SYM(r->r_info));
1734                 break;
1735         case R_ARM_PC24:
1736         case R_ARM_CALL:
1737         case R_ARM_JUMP24:
1738         case R_ARM_THM_CALL:
1739         case R_ARM_THM_JUMP24:
1740         case R_ARM_THM_JUMP19:
1741                 /* From ARM ABI: ((S + A) | T) - P */
1742                 r->r_addend = (int)(long)(elf->hdr +
1743                               sechdr->sh_offset +
1744                               (r->r_offset - sechdr->sh_addr));
1745                 break;
1746         default:
1747                 return 1;
1748         }
1749         return 0;
1750 }
1751
1752 static int addend_mips_rel(struct elf_info *elf, Elf_Shdr *sechdr, Elf_Rela *r)
1753 {
1754         unsigned int r_typ = ELF_R_TYPE(r->r_info);
1755         unsigned int *location = reloc_location(elf, sechdr, r);
1756         unsigned int inst;
1757
1758         if (r_typ == R_MIPS_HI16)
1759                 return 1;       /* skip this */
1760         inst = TO_NATIVE(*location);
1761         switch (r_typ) {
1762         case R_MIPS_LO16:
1763                 r->r_addend = inst & 0xffff;
1764                 break;
1765         case R_MIPS_26:
1766                 r->r_addend = (inst & 0x03ffffff) << 2;
1767                 break;
1768         case R_MIPS_32:
1769                 r->r_addend = inst;
1770                 break;
1771         }
1772         return 0;
1773 }
1774
1775 static void section_rela(const char *modname, struct elf_info *elf,
1776                          Elf_Shdr *sechdr)
1777 {
1778         Elf_Sym  *sym;
1779         Elf_Rela *rela;
1780         Elf_Rela r;
1781         unsigned int r_sym;
1782         const char *fromsec;
1783
1784         Elf_Rela *start = (void *)elf->hdr + sechdr->sh_offset;
1785         Elf_Rela *stop  = (void *)start + sechdr->sh_size;
1786
1787         fromsec = sech_name(elf, sechdr);
1788         fromsec += strlen(".rela");
1789         /* if from section (name) is know good then skip it */
1790         if (match(fromsec, section_white_list))
1791                 return;
1792
1793         for (rela = start; rela < stop; rela++) {
1794                 r.r_offset = TO_NATIVE(rela->r_offset);
1795 #if KERNEL_ELFCLASS == ELFCLASS64
1796                 if (elf->hdr->e_machine == EM_MIPS) {
1797                         unsigned int r_typ;
1798                         r_sym = ELF64_MIPS_R_SYM(rela->r_info);
1799                         r_sym = TO_NATIVE(r_sym);
1800                         r_typ = ELF64_MIPS_R_TYPE(rela->r_info);
1801                         r.r_info = ELF64_R_INFO(r_sym, r_typ);
1802                 } else {
1803                         r.r_info = TO_NATIVE(rela->r_info);
1804                         r_sym = ELF_R_SYM(r.r_info);
1805                 }
1806 #else
1807                 r.r_info = TO_NATIVE(rela->r_info);
1808                 r_sym = ELF_R_SYM(r.r_info);
1809 #endif
1810                 r.r_addend = TO_NATIVE(rela->r_addend);
1811                 sym = elf->symtab_start + r_sym;
1812                 /* Skip special sections */
1813                 if (is_shndx_special(sym->st_shndx))
1814                         continue;
1815                 if (is_second_extable_reloc(start, rela, fromsec))
1816                         find_extable_entry_size(fromsec, &r);
1817                 check_section_mismatch(modname, elf, &r, sym, fromsec);
1818         }
1819 }
1820
1821 static void section_rel(const char *modname, struct elf_info *elf,
1822                         Elf_Shdr *sechdr)
1823 {
1824         Elf_Sym *sym;
1825         Elf_Rel *rel;
1826         Elf_Rela r;
1827         unsigned int r_sym;
1828         const char *fromsec;
1829
1830         Elf_Rel *start = (void *)elf->hdr + sechdr->sh_offset;
1831         Elf_Rel *stop  = (void *)start + sechdr->sh_size;
1832
1833         fromsec = sech_name(elf, sechdr);
1834         fromsec += strlen(".rel");
1835         /* if from section (name) is know good then skip it */
1836         if (match(fromsec, section_white_list))
1837                 return;
1838
1839         for (rel = start; rel < stop; rel++) {
1840                 r.r_offset = TO_NATIVE(rel->r_offset);
1841 #if KERNEL_ELFCLASS == ELFCLASS64
1842                 if (elf->hdr->e_machine == EM_MIPS) {
1843                         unsigned int r_typ;
1844                         r_sym = ELF64_MIPS_R_SYM(rel->r_info);
1845                         r_sym = TO_NATIVE(r_sym);
1846                         r_typ = ELF64_MIPS_R_TYPE(rel->r_info);
1847                         r.r_info = ELF64_R_INFO(r_sym, r_typ);
1848                 } else {
1849                         r.r_info = TO_NATIVE(rel->r_info);
1850                         r_sym = ELF_R_SYM(r.r_info);
1851                 }
1852 #else
1853                 r.r_info = TO_NATIVE(rel->r_info);
1854                 r_sym = ELF_R_SYM(r.r_info);
1855 #endif
1856                 r.r_addend = 0;
1857                 switch (elf->hdr->e_machine) {
1858                 case EM_386:
1859                         if (addend_386_rel(elf, sechdr, &r))
1860                                 continue;
1861                         break;
1862                 case EM_ARM:
1863                         if (addend_arm_rel(elf, sechdr, &r))
1864                                 continue;
1865                         break;
1866                 case EM_MIPS:
1867                         if (addend_mips_rel(elf, sechdr, &r))
1868                                 continue;
1869                         break;
1870                 }
1871                 sym = elf->symtab_start + r_sym;
1872                 /* Skip special sections */
1873                 if (is_shndx_special(sym->st_shndx))
1874                         continue;
1875                 if (is_second_extable_reloc(start, rel, fromsec))
1876                         find_extable_entry_size(fromsec, &r);
1877                 check_section_mismatch(modname, elf, &r, sym, fromsec);
1878         }
1879 }
1880
1881 /**
1882  * A module includes a number of sections that are discarded
1883  * either when loaded or when used as built-in.
1884  * For loaded modules all functions marked __init and all data
1885  * marked __initdata will be discarded when the module has been initialized.
1886  * Likewise for modules used built-in the sections marked __exit
1887  * are discarded because __exit marked function are supposed to be called
1888  * only when a module is unloaded which never happens for built-in modules.
1889  * The check_sec_ref() function traverses all relocation records
1890  * to find all references to a section that reference a section that will
1891  * be discarded and warns about it.
1892  **/
1893 static void check_sec_ref(struct module *mod, const char *modname,
1894                           struct elf_info *elf)
1895 {
1896         int i;
1897         Elf_Shdr *sechdrs = elf->sechdrs;
1898
1899         /* Walk through all sections */
1900         for (i = 0; i < elf->num_sections; i++) {
1901                 check_section(modname, elf, &elf->sechdrs[i]);
1902                 /* We want to process only relocation sections and not .init */
1903                 if (sechdrs[i].sh_type == SHT_RELA)
1904                         section_rela(modname, elf, &elf->sechdrs[i]);
1905                 else if (sechdrs[i].sh_type == SHT_REL)
1906                         section_rel(modname, elf, &elf->sechdrs[i]);
1907         }
1908 }
1909
1910 static char *remove_dot(char *s)
1911 {
1912         size_t n = strcspn(s, ".");
1913
1914         if (n && s[n]) {
1915                 size_t m = strspn(s + n + 1, "0123456789");
1916                 if (m && (s[n + m] == '.' || s[n + m] == 0))
1917                         s[n] = 0;
1918         }
1919         return s;
1920 }
1921
1922 static void read_symbols(char *modname)
1923 {
1924         const char *symname;
1925         char *version;
1926         char *license;
1927         struct module *mod;
1928         struct elf_info info = { };
1929         Elf_Sym *sym;
1930
1931         if (!parse_elf(&info, modname))
1932                 return;
1933
1934         mod = new_module(modname);
1935
1936         /* When there's no vmlinux, don't print warnings about
1937          * unresolved symbols (since there'll be too many ;) */
1938         if (is_vmlinux(modname)) {
1939                 have_vmlinux = 1;
1940                 mod->skip = 1;
1941         }
1942
1943         license = get_modinfo(info.modinfo, info.modinfo_len, "license");
1944         if (info.modinfo && !license && !is_vmlinux(modname))
1945                 warn("modpost: missing MODULE_LICENSE() in %s\n"
1946                      "see include/linux/module.h for "
1947                      "more information\n", modname);
1948         while (license) {
1949                 if (license_is_gpl_compatible(license))
1950                         mod->gpl_compatible = 1;
1951                 else {
1952                         mod->gpl_compatible = 0;
1953                         break;
1954                 }
1955                 license = get_next_modinfo(info.modinfo, info.modinfo_len,
1956                                            "license", license);
1957         }
1958
1959         for (sym = info.symtab_start; sym < info.symtab_stop; sym++) {
1960                 symname = remove_dot(info.strtab + sym->st_name);
1961
1962                 handle_modversions(mod, &info, sym, symname);
1963                 handle_moddevtable(mod, &info, sym, symname);
1964         }
1965         if (!is_vmlinux(modname) ||
1966              (is_vmlinux(modname) && vmlinux_section_warnings))
1967                 check_sec_ref(mod, modname, &info);
1968
1969         version = get_modinfo(info.modinfo, info.modinfo_len, "version");
1970         if (version)
1971                 maybe_frob_rcs_version(modname, version, info.modinfo,
1972                                        version - (char *)info.hdr);
1973         if (version || (all_versions && !is_vmlinux(modname)))
1974                 get_src_version(modname, mod->srcversion,
1975                                 sizeof(mod->srcversion)-1);
1976
1977         parse_elf_finish(&info);
1978
1979         /* Our trick to get versioning for module struct etc. - it's
1980          * never passed as an argument to an exported function, so
1981          * the automatic versioning doesn't pick it up, but it's really
1982          * important anyhow */
1983         if (modversions)
1984                 mod->unres = alloc_symbol("module_layout", 0, mod->unres);
1985 }
1986
1987 static void read_symbols_from_files(const char *filename)
1988 {
1989         FILE *in = stdin;
1990         char fname[PATH_MAX];
1991
1992         if (strcmp(filename, "-") != 0) {
1993                 in = fopen(filename, "r");
1994                 if (!in)
1995                         fatal("Can't open filenames file %s: %m", filename);
1996         }
1997
1998         while (fgets(fname, PATH_MAX, in) != NULL) {
1999                 if (strends(fname, "\n"))
2000                         fname[strlen(fname)-1] = '\0';
2001                 read_symbols(fname);
2002         }
2003
2004         if (in != stdin)
2005                 fclose(in);
2006 }
2007
2008 #define SZ 500
2009
2010 /* We first write the generated file into memory using the
2011  * following helper, then compare to the file on disk and
2012  * only update the later if anything changed */
2013
2014 void __attribute__((format(printf, 2, 3))) buf_printf(struct buffer *buf,
2015                                                       const char *fmt, ...)
2016 {
2017         char tmp[SZ];
2018         int len;
2019         va_list ap;
2020
2021         va_start(ap, fmt);
2022         len = vsnprintf(tmp, SZ, fmt, ap);
2023         buf_write(buf, tmp, len);
2024         va_end(ap);
2025 }
2026
2027 void buf_write(struct buffer *buf, const char *s, int len)
2028 {
2029         if (buf->size - buf->pos < len) {
2030                 buf->size += len + SZ;
2031                 buf->p = realloc(buf->p, buf->size);
2032         }
2033         strncpy(buf->p + buf->pos, s, len);
2034         buf->pos += len;
2035 }
2036
2037 static void check_for_gpl_usage(enum export exp, const char *m, const char *s)
2038 {
2039         const char *e = is_vmlinux(m) ?"":".ko";
2040
2041         switch (exp) {
2042         case export_gpl:
2043                 fatal("modpost: GPL-incompatible module %s%s "
2044                       "uses GPL-only symbol '%s'\n", m, e, s);
2045                 break;
2046         case export_unused_gpl:
2047                 fatal("modpost: GPL-incompatible module %s%s "
2048                       "uses GPL-only symbol marked UNUSED '%s'\n", m, e, s);
2049                 break;
2050         case export_gpl_future:
2051                 warn("modpost: GPL-incompatible module %s%s "
2052                       "uses future GPL-only symbol '%s'\n", m, e, s);
2053                 break;
2054         case export_plain:
2055         case export_unused:
2056         case export_unknown:
2057                 /* ignore */
2058                 break;
2059         }
2060 }
2061
2062 static void check_for_unused(enum export exp, const char *m, const char *s)
2063 {
2064         const char *e = is_vmlinux(m) ?"":".ko";
2065
2066         switch (exp) {
2067         case export_unused:
2068         case export_unused_gpl:
2069                 warn("modpost: module %s%s "
2070                       "uses symbol '%s' marked UNUSED\n", m, e, s);
2071                 break;
2072         default:
2073                 /* ignore */
2074                 break;
2075         }
2076 }
2077
2078 static void check_exports(struct module *mod)
2079 {
2080         struct symbol *s, *exp;
2081
2082         for (s = mod->unres; s; s = s->next) {
2083                 const char *basename;
2084                 exp = find_symbol(s->name);
2085                 if (!exp || exp->module == mod)
2086                         continue;
2087                 basename = strrchr(mod->name, '/');
2088                 if (basename)
2089                         basename++;
2090                 else
2091                         basename = mod->name;
2092                 if (!mod->gpl_compatible)
2093                         check_for_gpl_usage(exp->export, basename, exp->name);
2094                 check_for_unused(exp->export, basename, exp->name);
2095         }
2096 }
2097
2098 /**
2099  * Header for the generated file
2100  **/
2101 static void add_header(struct buffer *b, struct module *mod)
2102 {
2103         buf_printf(b, "#include <linux/module.h>\n");
2104         buf_printf(b, "#include <linux/vermagic.h>\n");
2105         buf_printf(b, "#include <linux/compiler.h>\n");
2106         buf_printf(b, "\n");
2107         buf_printf(b, "MODULE_INFO(vermagic, VERMAGIC_STRING);\n");
2108         buf_printf(b, "\n");
2109         buf_printf(b, "__visible struct module __this_module\n");
2110         buf_printf(b, "__attribute__((section(\".gnu.linkonce.this_module\"))) = {\n");
2111         buf_printf(b, "\t.name = KBUILD_MODNAME,\n");
2112         if (mod->has_init)
2113                 buf_printf(b, "\t.init = init_module,\n");
2114         if (mod->has_cleanup)
2115                 buf_printf(b, "#ifdef CONFIG_MODULE_UNLOAD\n"
2116                               "\t.exit = cleanup_module,\n"
2117                               "#endif\n");
2118         buf_printf(b, "\t.arch = MODULE_ARCH_INIT,\n");
2119         buf_printf(b, "};\n");
2120 }
2121
2122 static void add_intree_flag(struct buffer *b, int is_intree)
2123 {
2124         if (is_intree)
2125                 buf_printf(b, "\nMODULE_INFO(intree, \"Y\");\n");
2126 }
2127
2128 static void add_staging_flag(struct buffer *b, const char *name)
2129 {
2130         static const char *staging_dir = "drivers/staging";
2131
2132         if (strncmp(staging_dir, name, strlen(staging_dir)) == 0)
2133                 buf_printf(b, "\nMODULE_INFO(staging, \"Y\");\n");
2134 }
2135
2136 /**
2137  * Record CRCs for unresolved symbols
2138  **/
2139 static int add_versions(struct buffer *b, struct module *mod)
2140 {
2141         struct symbol *s, *exp;
2142         int err = 0;
2143
2144         for (s = mod->unres; s; s = s->next) {
2145                 exp = find_symbol(s->name);
2146                 if (!exp || exp->module == mod) {
2147                         if (have_vmlinux && !s->weak) {
2148                                 if (warn_unresolved) {
2149                                         warn("\"%s\" [%s.ko] undefined!\n",
2150                                              s->name, mod->name);
2151                                 } else {
2152                                         merror("\"%s\" [%s.ko] undefined!\n",
2153                                                s->name, mod->name);
2154                                         err = 1;
2155                                 }
2156                         }
2157                         continue;
2158                 }
2159                 s->module = exp->module;
2160                 s->crc_valid = exp->crc_valid;
2161                 s->crc = exp->crc;
2162         }
2163
2164         if (!modversions)
2165                 return err;
2166
2167         buf_printf(b, "\n");
2168         buf_printf(b, "static const struct modversion_info ____versions[]\n");
2169         buf_printf(b, "__used\n");
2170         buf_printf(b, "__attribute__((section(\"__versions\"))) = {\n");
2171
2172         for (s = mod->unres; s; s = s->next) {
2173                 if (!s->module)
2174                         continue;
2175                 if (!s->crc_valid) {
2176                         warn("\"%s\" [%s.ko] has no CRC!\n",
2177                                 s->name, mod->name);
2178                         continue;
2179                 }
2180                 buf_printf(b, "\t{ %#8x, __VMLINUX_SYMBOL_STR(%s) },\n",
2181                            s->crc, s->name);
2182         }
2183
2184         buf_printf(b, "};\n");
2185
2186         return err;
2187 }
2188
2189 static void add_depends(struct buffer *b, struct module *mod,
2190                         struct module *modules)
2191 {
2192         struct symbol *s;
2193         struct module *m;
2194         int first = 1;
2195
2196         for (m = modules; m; m = m->next)
2197                 m->seen = is_vmlinux(m->name);
2198
2199         buf_printf(b, "\n");
2200         buf_printf(b, "static const char __module_depends[]\n");
2201         buf_printf(b, "__used\n");
2202         buf_printf(b, "__attribute__((section(\".modinfo\"))) =\n");
2203         buf_printf(b, "\"depends=");
2204         for (s = mod->unres; s; s = s->next) {
2205                 const char *p;
2206                 if (!s->module)
2207                         continue;
2208
2209                 if (s->module->seen)
2210                         continue;
2211
2212                 s->module->seen = 1;
2213                 p = strrchr(s->module->name, '/');
2214                 if (p)
2215                         p++;
2216                 else
2217                         p = s->module->name;
2218                 buf_printf(b, "%s%s", first ? "" : ",", p);
2219                 first = 0;
2220         }
2221         buf_printf(b, "\";\n");
2222 }
2223
2224 static void add_srcversion(struct buffer *b, struct module *mod)
2225 {
2226         if (mod->srcversion[0]) {
2227                 buf_printf(b, "\n");
2228                 buf_printf(b, "MODULE_INFO(srcversion, \"%s\");\n",
2229                            mod->srcversion);
2230         }
2231 }
2232
2233 static void write_if_changed(struct buffer *b, const char *fname)
2234 {
2235         char *tmp;
2236         FILE *file;
2237         struct stat st;
2238
2239         file = fopen(fname, "r");
2240         if (!file)
2241                 goto write;
2242
2243         if (fstat(fileno(file), &st) < 0)
2244                 goto close_write;
2245
2246         if (st.st_size != b->pos)
2247                 goto close_write;
2248
2249         tmp = NOFAIL(malloc(b->pos));
2250         if (fread(tmp, 1, b->pos, file) != b->pos)
2251                 goto free_write;
2252
2253         if (memcmp(tmp, b->p, b->pos) != 0)
2254                 goto free_write;
2255
2256         free(tmp);
2257         fclose(file);
2258         return;
2259
2260  free_write:
2261         free(tmp);
2262  close_write:
2263         fclose(file);
2264  write:
2265         file = fopen(fname, "w");
2266         if (!file) {
2267                 perror(fname);
2268                 exit(1);
2269         }
2270         if (fwrite(b->p, 1, b->pos, file) != b->pos) {
2271                 perror(fname);
2272                 exit(1);
2273         }
2274         fclose(file);
2275 }
2276
2277 /* parse Module.symvers file. line format:
2278  * 0x12345678<tab>symbol<tab>module[[<tab>export]<tab>something]
2279  **/
2280 static void read_dump(const char *fname, unsigned int kernel)
2281 {
2282         unsigned long size, pos = 0;
2283         void *file = grab_file(fname, &size);
2284         char *line;
2285
2286         if (!file)
2287                 /* No symbol versions, silently ignore */
2288                 return;
2289
2290         while ((line = get_next_line(&pos, file, size))) {
2291                 char *symname, *modname, *d, *export, *end;
2292                 unsigned int crc;
2293                 struct module *mod;
2294                 struct symbol *s;
2295
2296                 if (!(symname = strchr(line, '\t')))
2297                         goto fail;
2298                 *symname++ = '\0';
2299                 if (!(modname = strchr(symname, '\t')))
2300                         goto fail;
2301                 *modname++ = '\0';
2302                 if ((export = strchr(modname, '\t')) != NULL)
2303                         *export++ = '\0';
2304                 if (export && ((end = strchr(export, '\t')) != NULL))
2305                         *end = '\0';
2306                 crc = strtoul(line, &d, 16);
2307                 if (*symname == '\0' || *modname == '\0' || *d != '\0')
2308                         goto fail;
2309                 mod = find_module(modname);
2310                 if (!mod) {
2311                         if (is_vmlinux(modname))
2312                                 have_vmlinux = 1;
2313                         mod = new_module(modname);
2314                         mod->skip = 1;
2315                 }
2316                 s = sym_add_exported(symname, mod, export_no(export));
2317                 s->kernel    = kernel;
2318                 s->preloaded = 1;
2319                 sym_update_crc(symname, mod, crc, export_no(export));
2320         }
2321         release_file(file, size);
2322         return;
2323 fail:
2324         release_file(file, size);
2325         fatal("parse error in symbol dump file\n");
2326 }
2327
2328 /* For normal builds always dump all symbols.
2329  * For external modules only dump symbols
2330  * that are not read from kernel Module.symvers.
2331  **/
2332 static int dump_sym(struct symbol *sym)
2333 {
2334         if (!external_module)
2335                 return 1;
2336         if (sym->vmlinux || sym->kernel)
2337                 return 0;
2338         return 1;
2339 }
2340
2341 static void write_dump(const char *fname)
2342 {
2343         struct buffer buf = { };
2344         struct symbol *symbol;
2345         int n;
2346
2347         for (n = 0; n < SYMBOL_HASH_SIZE ; n++) {
2348                 symbol = symbolhash[n];
2349                 while (symbol) {
2350                         if (dump_sym(symbol))
2351                                 buf_printf(&buf, "0x%08x\t%s\t%s\t%s\n",
2352                                         symbol->crc, symbol->name,
2353                                         symbol->module->name,
2354                                         export_str(symbol->export));
2355                         symbol = symbol->next;
2356                 }
2357         }
2358         write_if_changed(&buf, fname);
2359 }
2360
2361 struct ext_sym_list {
2362         struct ext_sym_list *next;
2363         const char *file;
2364 };
2365
2366 int main(int argc, char **argv)
2367 {
2368         struct module *mod;
2369         struct buffer buf = { };
2370         char *kernel_read = NULL, *module_read = NULL;
2371         char *dump_write = NULL, *files_source = NULL;
2372         int opt;
2373         int err;
2374         struct ext_sym_list *extsym_iter;
2375         struct ext_sym_list *extsym_start = NULL;
2376
2377         while ((opt = getopt(argc, argv, "i:I:e:mnsST:o:awM:K:")) != -1) {
2378                 switch (opt) {
2379                 case 'i':
2380                         kernel_read = optarg;
2381                         break;
2382                 case 'I':
2383                         module_read = optarg;
2384                         external_module = 1;
2385                         break;
2386                 case 'e':
2387                         external_module = 1;
2388                         extsym_iter =
2389                            NOFAIL(malloc(sizeof(*extsym_iter)));
2390                         extsym_iter->next = extsym_start;
2391                         extsym_iter->file = optarg;
2392                         extsym_start = extsym_iter;
2393                         break;
2394                 case 'm':
2395                         modversions = 1;
2396                         break;
2397                 case 'n':
2398                         ignore_missing_files = 1;
2399                         break;
2400                 case 'o':
2401                         dump_write = optarg;
2402                         break;
2403                 case 'a':
2404                         all_versions = 1;
2405                         break;
2406                 case 's':
2407                         vmlinux_section_warnings = 0;
2408                         break;
2409                 case 'S':
2410                         sec_mismatch_verbose = 0;
2411                         break;
2412                 case 'T':
2413                         files_source = optarg;
2414                         break;
2415                 case 'w':
2416                         warn_unresolved = 1;
2417                         break;
2418                 default:
2419                         exit(1);
2420                 }
2421         }
2422
2423         if (kernel_read)
2424                 read_dump(kernel_read, 1);
2425         if (module_read)
2426                 read_dump(module_read, 0);
2427         while (extsym_start) {
2428                 read_dump(extsym_start->file, 0);
2429                 extsym_iter = extsym_start->next;
2430                 free(extsym_start);
2431                 extsym_start = extsym_iter;
2432         }
2433
2434         while (optind < argc)
2435                 read_symbols(argv[optind++]);
2436
2437         if (files_source)
2438                 read_symbols_from_files(files_source);
2439
2440         for (mod = modules; mod; mod = mod->next) {
2441                 if (mod->skip)
2442                         continue;
2443                 check_exports(mod);
2444         }
2445
2446         err = 0;
2447
2448         for (mod = modules; mod; mod = mod->next) {
2449                 char fname[PATH_MAX];
2450
2451                 if (mod->skip)
2452                         continue;
2453
2454                 buf.pos = 0;
2455
2456                 add_header(&buf, mod);
2457                 add_intree_flag(&buf, !external_module);
2458                 add_staging_flag(&buf, mod->name);
2459                 err |= add_versions(&buf, mod);
2460                 add_depends(&buf, mod, modules);
2461                 add_moddevtable(&buf, mod);
2462                 add_srcversion(&buf, mod);
2463
2464                 sprintf(fname, "%s.mod.c", mod->name);
2465                 write_if_changed(&buf, fname);
2466         }
2467
2468         if (dump_write)
2469                 write_dump(dump_write);
2470         if (sec_mismatch_count && !sec_mismatch_verbose)
2471                 warn("modpost: Found %d section mismatch(es).\n"
2472                      "To see full details build your kernel with:\n"
2473                      "'make CONFIG_DEBUG_SECTION_MISMATCH=y'\n",
2474                      sec_mismatch_count);
2475
2476         return err;
2477 }