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