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