scripts/mod/modpost.c

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