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