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