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