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