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