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