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