scripts/mod/modpost.c

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