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