scripts/mod/modpost.c

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