Back to home page

LXR

 
 

    


0001 /* Postprocess module symbol versions
0002  *
0003  * Copyright 2003       Kai Germaschewski
0004  * Copyright 2002-2004  Rusty Russell, IBM Corporation
0005  * Copyright 2006-2008  Sam Ravnborg
0006  * Based in part on module-init-tools/depmod.c,file2alias
0007  *
0008  * This software may be used and distributed according to the terms
0009  * of the GNU General Public License, incorporated herein by reference.
0010  *
0011  * Usage: modpost vmlinux module1.o module2.o ...
0012  */
0013 
0014 #define _GNU_SOURCE
0015 #include <stdio.h>
0016 #include <ctype.h>
0017 #include <string.h>
0018 #include <limits.h>
0019 #include <stdbool.h>
0020 #include <errno.h>
0021 #include "modpost.h"
0022 #include "../../include/generated/autoconf.h"
0023 #include "../../include/linux/license.h"
0024 #include "../../include/linux/export.h"
0025 
0026 /* Are we using CONFIG_MODVERSIONS? */
0027 static int modversions = 0;
0028 /* Warn about undefined symbols? (do so if we have vmlinux) */
0029 static int have_vmlinux = 0;
0030 /* Is CONFIG_MODULE_SRCVERSION_ALL set? */
0031 static int all_versions = 0;
0032 /* If we are modposting external module set to 1 */
0033 static int external_module = 0;
0034 /* Warn about section mismatch in vmlinux if set to 1 */
0035 static int vmlinux_section_warnings = 1;
0036 /* Only warn about unresolved symbols */
0037 static int warn_unresolved = 0;
0038 /* How a symbol is exported */
0039 static int sec_mismatch_count = 0;
0040 static int sec_mismatch_verbose = 1;
0041 static int sec_mismatch_fatal = 0;
0042 /* ignore missing files */
0043 static int ignore_missing_files;
0044 
0045 enum export {
0046     export_plain,      export_unused,     export_gpl,
0047     export_unused_gpl, export_gpl_future, export_unknown
0048 };
0049 
0050 #define PRINTF __attribute__ ((format (printf, 1, 2)))
0051 
0052 PRINTF void fatal(const char *fmt, ...)
0053 {
0054     va_list arglist;
0055 
0056     fprintf(stderr, "FATAL: ");
0057 
0058     va_start(arglist, fmt);
0059     vfprintf(stderr, fmt, arglist);
0060     va_end(arglist);
0061 
0062     exit(1);
0063 }
0064 
0065 PRINTF void warn(const char *fmt, ...)
0066 {
0067     va_list arglist;
0068 
0069     fprintf(stderr, "WARNING: ");
0070 
0071     va_start(arglist, fmt);
0072     vfprintf(stderr, fmt, arglist);
0073     va_end(arglist);
0074 }
0075 
0076 PRINTF void merror(const char *fmt, ...)
0077 {
0078     va_list arglist;
0079 
0080     fprintf(stderr, "ERROR: ");
0081 
0082     va_start(arglist, fmt);
0083     vfprintf(stderr, fmt, arglist);
0084     va_end(arglist);
0085 }
0086 
0087 static inline bool strends(const char *str, const char *postfix)
0088 {
0089     if (strlen(str) < strlen(postfix))
0090         return false;
0091 
0092     return strcmp(str + strlen(str) - strlen(postfix), postfix) == 0;
0093 }
0094 
0095 static int is_vmlinux(const char *modname)
0096 {
0097     const char *myname;
0098 
0099     myname = strrchr(modname, '/');
0100     if (myname)
0101         myname++;
0102     else
0103         myname = modname;
0104 
0105     return (strcmp(myname, "vmlinux") == 0) ||
0106            (strcmp(myname, "vmlinux.o") == 0);
0107 }
0108 
0109 void *do_nofail(void *ptr, const char *expr)
0110 {
0111     if (!ptr)
0112         fatal("modpost: Memory allocation failure: %s.\n", expr);
0113 
0114     return ptr;
0115 }
0116 
0117 /* A list of all modules we processed */
0118 static struct module *modules;
0119 
0120 static struct module *find_module(char *modname)
0121 {
0122     struct module *mod;
0123 
0124     for (mod = modules; mod; mod = mod->next)
0125         if (strcmp(mod->name, modname) == 0)
0126             break;
0127     return mod;
0128 }
0129 
0130 static struct module *new_module(const char *modname)
0131 {
0132     struct module *mod;
0133     char *p;
0134 
0135     mod = NOFAIL(malloc(sizeof(*mod)));
0136     memset(mod, 0, sizeof(*mod));
0137     p = NOFAIL(strdup(modname));
0138 
0139     /* strip trailing .o */
0140     if (strends(p, ".o")) {
0141         p[strlen(p) - 2] = '\0';
0142         mod->is_dot_o = 1;
0143     }
0144 
0145     /* add to list */
0146     mod->name = p;
0147     mod->gpl_compatible = -1;
0148     mod->next = modules;
0149     modules = mod;
0150 
0151     return mod;
0152 }
0153 
0154 /* A hash of all exported symbols,
0155  * struct symbol is also used for lists of unresolved symbols */
0156 
0157 #define SYMBOL_HASH_SIZE 1024
0158 
0159 struct symbol {
0160     struct symbol *next;
0161     struct module *module;
0162     unsigned int crc;
0163     int crc_valid;
0164     unsigned int weak:1;
0165     unsigned int vmlinux:1;    /* 1 if symbol is defined in vmlinux */
0166     unsigned int kernel:1;     /* 1 if symbol is from kernel
0167                     *  (only for external modules) **/
0168     unsigned int preloaded:1;  /* 1 if symbol from Module.symvers, or crc */
0169     enum export  export;       /* Type of export */
0170     char name[0];
0171 };
0172 
0173 static struct symbol *symbolhash[SYMBOL_HASH_SIZE];
0174 
0175 /* This is based on the hash agorithm from gdbm, via tdb */
0176 static inline unsigned int tdb_hash(const char *name)
0177 {
0178     unsigned value; /* Used to compute the hash value.  */
0179     unsigned   i;   /* Used to cycle through random values. */
0180 
0181     /* Set the initial value from the key size. */
0182     for (value = 0x238F13AF * strlen(name), i = 0; name[i]; i++)
0183         value = (value + (((unsigned char *)name)[i] << (i*5 % 24)));
0184 
0185     return (1103515243 * value + 12345);
0186 }
0187 
0188 /**
0189  * Allocate a new symbols for use in the hash of exported symbols or
0190  * the list of unresolved symbols per module
0191  **/
0192 static struct symbol *alloc_symbol(const char *name, unsigned int weak,
0193                    struct symbol *next)
0194 {
0195     struct symbol *s = NOFAIL(malloc(sizeof(*s) + strlen(name) + 1));
0196 
0197     memset(s, 0, sizeof(*s));
0198     strcpy(s->name, name);
0199     s->weak = weak;
0200     s->next = next;
0201     return s;
0202 }
0203 
0204 /* For the hash of exported symbols */
0205 static struct symbol *new_symbol(const char *name, struct module *module,
0206                  enum export export)
0207 {
0208     unsigned int hash;
0209     struct symbol *new;
0210 
0211     hash = tdb_hash(name) % SYMBOL_HASH_SIZE;
0212     new = symbolhash[hash] = alloc_symbol(name, 0, symbolhash[hash]);
0213     new->module = module;
0214     new->export = export;
0215     return new;
0216 }
0217 
0218 static struct symbol *find_symbol(const char *name)
0219 {
0220     struct symbol *s;
0221 
0222     /* For our purposes, .foo matches foo.  PPC64 needs this. */
0223     if (name[0] == '.')
0224         name++;
0225 
0226     for (s = symbolhash[tdb_hash(name) % SYMBOL_HASH_SIZE]; s; s = s->next) {
0227         if (strcmp(s->name, name) == 0)
0228             return s;
0229     }
0230     return NULL;
0231 }
0232 
0233 static const struct {
0234     const char *str;
0235     enum export export;
0236 } export_list[] = {
0237     { .str = "EXPORT_SYMBOL",            .export = export_plain },
0238     { .str = "EXPORT_UNUSED_SYMBOL",     .export = export_unused },
0239     { .str = "EXPORT_SYMBOL_GPL",        .export = export_gpl },
0240     { .str = "EXPORT_UNUSED_SYMBOL_GPL", .export = export_unused_gpl },
0241     { .str = "EXPORT_SYMBOL_GPL_FUTURE", .export = export_gpl_future },
0242     { .str = "(unknown)",                .export = export_unknown },
0243 };
0244 
0245 
0246 static const char *export_str(enum export ex)
0247 {
0248     return export_list[ex].str;
0249 }
0250 
0251 static enum export export_no(const char *s)
0252 {
0253     int i;
0254 
0255     if (!s)
0256         return export_unknown;
0257     for (i = 0; export_list[i].export != export_unknown; i++) {
0258         if (strcmp(export_list[i].str, s) == 0)
0259             return export_list[i].export;
0260     }
0261     return export_unknown;
0262 }
0263 
0264 static const char *sec_name(struct elf_info *elf, int secindex);
0265 
0266 #define strstarts(str, prefix) (strncmp(str, prefix, strlen(prefix)) == 0)
0267 
0268 static enum export export_from_secname(struct elf_info *elf, unsigned int sec)
0269 {
0270     const char *secname = sec_name(elf, sec);
0271 
0272     if (strstarts(secname, "___ksymtab+"))
0273         return export_plain;
0274     else if (strstarts(secname, "___ksymtab_unused+"))
0275         return export_unused;
0276     else if (strstarts(secname, "___ksymtab_gpl+"))
0277         return export_gpl;
0278     else if (strstarts(secname, "___ksymtab_unused_gpl+"))
0279         return export_unused_gpl;
0280     else if (strstarts(secname, "___ksymtab_gpl_future+"))
0281         return export_gpl_future;
0282     else
0283         return export_unknown;
0284 }
0285 
0286 static enum export export_from_sec(struct elf_info *elf, unsigned int sec)
0287 {
0288     if (sec == elf->export_sec)
0289         return export_plain;
0290     else if (sec == elf->export_unused_sec)
0291         return export_unused;
0292     else if (sec == elf->export_gpl_sec)
0293         return export_gpl;
0294     else if (sec == elf->export_unused_gpl_sec)
0295         return export_unused_gpl;
0296     else if (sec == elf->export_gpl_future_sec)
0297         return export_gpl_future;
0298     else
0299         return export_unknown;
0300 }
0301 
0302 /**
0303  * Add an exported symbol - it may have already been added without a
0304  * CRC, in this case just update the CRC
0305  **/
0306 static struct symbol *sym_add_exported(const char *name, struct module *mod,
0307                        enum export export)
0308 {
0309     struct symbol *s = find_symbol(name);
0310 
0311     if (!s) {
0312         s = new_symbol(name, mod, export);
0313     } else {
0314         if (!s->preloaded) {
0315             warn("%s: '%s' exported twice. Previous export "
0316                  "was in %s%s\n", mod->name, name,
0317                  s->module->name,
0318                  is_vmlinux(s->module->name) ?"":".ko");
0319         } else {
0320             /* In case Module.symvers was out of date */
0321             s->module = mod;
0322         }
0323     }
0324     s->preloaded = 0;
0325     s->vmlinux   = is_vmlinux(mod->name);
0326     s->kernel    = 0;
0327     s->export    = export;
0328     return s;
0329 }
0330 
0331 static void sym_update_crc(const char *name, struct module *mod,
0332                unsigned int crc, enum export export)
0333 {
0334     struct symbol *s = find_symbol(name);
0335 
0336     if (!s) {
0337         s = new_symbol(name, mod, export);
0338         /* Don't complain when we find it later. */
0339         s->preloaded = 1;
0340     }
0341     s->crc = crc;
0342     s->crc_valid = 1;
0343 }
0344 
0345 void *grab_file(const char *filename, unsigned long *size)
0346 {
0347     struct stat st;
0348     void *map = MAP_FAILED;
0349     int fd;
0350 
0351     fd = open(filename, O_RDONLY);
0352     if (fd < 0)
0353         return NULL;
0354     if (fstat(fd, &st))
0355         goto failed;
0356 
0357     *size = st.st_size;
0358     map = mmap(NULL, *size, PROT_READ|PROT_WRITE, MAP_PRIVATE, fd, 0);
0359 
0360 failed:
0361     close(fd);
0362     if (map == MAP_FAILED)
0363         return NULL;
0364     return map;
0365 }
0366 
0367 /**
0368   * Return a copy of the next line in a mmap'ed file.
0369   * spaces in the beginning of the line is trimmed away.
0370   * Return a pointer to a static buffer.
0371   **/
0372 char *get_next_line(unsigned long *pos, void *file, unsigned long size)
0373 {
0374     static char line[4096];
0375     int skip = 1;
0376     size_t len = 0;
0377     signed char *p = (signed char *)file + *pos;
0378     char *s = line;
0379 
0380     for (; *pos < size ; (*pos)++) {
0381         if (skip && isspace(*p)) {
0382             p++;
0383             continue;
0384         }
0385         skip = 0;
0386         if (*p != '\n' && (*pos < size)) {
0387             len++;
0388             *s++ = *p++;
0389             if (len > 4095)
0390                 break; /* Too long, stop */
0391         } else {
0392             /* End of string */
0393             *s = '\0';
0394             return line;
0395         }
0396     }
0397     /* End of buffer */
0398     return NULL;
0399 }
0400 
0401 void release_file(void *file, unsigned long size)
0402 {
0403     munmap(file, size);
0404 }
0405 
0406 static int parse_elf(struct elf_info *info, const char *filename)
0407 {
0408     unsigned int i;
0409     Elf_Ehdr *hdr;
0410     Elf_Shdr *sechdrs;
0411     Elf_Sym  *sym;
0412     const char *secstrings;
0413     unsigned int symtab_idx = ~0U, symtab_shndx_idx = ~0U;
0414 
0415     hdr = grab_file(filename, &info->size);
0416     if (!hdr) {
0417         if (ignore_missing_files) {
0418             fprintf(stderr, "%s: %s (ignored)\n", filename,
0419                 strerror(errno));
0420             return 0;
0421         }
0422         perror(filename);
0423         exit(1);
0424     }
0425     info->hdr = hdr;
0426     if (info->size < sizeof(*hdr)) {
0427         /* file too small, assume this is an empty .o file */
0428         return 0;
0429     }
0430     /* Is this a valid ELF file? */
0431     if ((hdr->e_ident[EI_MAG0] != ELFMAG0) ||
0432         (hdr->e_ident[EI_MAG1] != ELFMAG1) ||
0433         (hdr->e_ident[EI_MAG2] != ELFMAG2) ||
0434         (hdr->e_ident[EI_MAG3] != ELFMAG3)) {
0435         /* Not an ELF file - silently ignore it */
0436         return 0;
0437     }
0438     /* Fix endianness in ELF header */
0439     hdr->e_type      = TO_NATIVE(hdr->e_type);
0440     hdr->e_machine   = TO_NATIVE(hdr->e_machine);
0441     hdr->e_version   = TO_NATIVE(hdr->e_version);
0442     hdr->e_entry     = TO_NATIVE(hdr->e_entry);
0443     hdr->e_phoff     = TO_NATIVE(hdr->e_phoff);
0444     hdr->e_shoff     = TO_NATIVE(hdr->e_shoff);
0445     hdr->e_flags     = TO_NATIVE(hdr->e_flags);
0446     hdr->e_ehsize    = TO_NATIVE(hdr->e_ehsize);
0447     hdr->e_phentsize = TO_NATIVE(hdr->e_phentsize);
0448     hdr->e_phnum     = TO_NATIVE(hdr->e_phnum);
0449     hdr->e_shentsize = TO_NATIVE(hdr->e_shentsize);
0450     hdr->e_shnum     = TO_NATIVE(hdr->e_shnum);
0451     hdr->e_shstrndx  = TO_NATIVE(hdr->e_shstrndx);
0452     sechdrs = (void *)hdr + hdr->e_shoff;
0453     info->sechdrs = sechdrs;
0454 
0455     /* Check if file offset is correct */
0456     if (hdr->e_shoff > info->size) {
0457         fatal("section header offset=%lu in file '%s' is bigger than "
0458               "filesize=%lu\n", (unsigned long)hdr->e_shoff,
0459               filename, info->size);
0460         return 0;
0461     }
0462 
0463     if (hdr->e_shnum == SHN_UNDEF) {
0464         /*
0465          * There are more than 64k sections,
0466          * read count from .sh_size.
0467          */
0468         info->num_sections = TO_NATIVE(sechdrs[0].sh_size);
0469     }
0470     else {
0471         info->num_sections = hdr->e_shnum;
0472     }
0473     if (hdr->e_shstrndx == SHN_XINDEX) {
0474         info->secindex_strings = TO_NATIVE(sechdrs[0].sh_link);
0475     }
0476     else {
0477         info->secindex_strings = hdr->e_shstrndx;
0478     }
0479 
0480     /* Fix endianness in section headers */
0481     for (i = 0; i < info->num_sections; i++) {
0482         sechdrs[i].sh_name      = TO_NATIVE(sechdrs[i].sh_name);
0483         sechdrs[i].sh_type      = TO_NATIVE(sechdrs[i].sh_type);
0484         sechdrs[i].sh_flags     = TO_NATIVE(sechdrs[i].sh_flags);
0485         sechdrs[i].sh_addr      = TO_NATIVE(sechdrs[i].sh_addr);
0486         sechdrs[i].sh_offset    = TO_NATIVE(sechdrs[i].sh_offset);
0487         sechdrs[i].sh_size      = TO_NATIVE(sechdrs[i].sh_size);
0488         sechdrs[i].sh_link      = TO_NATIVE(sechdrs[i].sh_link);
0489         sechdrs[i].sh_info      = TO_NATIVE(sechdrs[i].sh_info);
0490         sechdrs[i].sh_addralign = TO_NATIVE(sechdrs[i].sh_addralign);
0491         sechdrs[i].sh_entsize   = TO_NATIVE(sechdrs[i].sh_entsize);
0492     }
0493     /* Find symbol table. */
0494     secstrings = (void *)hdr + sechdrs[info->secindex_strings].sh_offset;
0495     for (i = 1; i < info->num_sections; i++) {
0496         const char *secname;
0497         int nobits = sechdrs[i].sh_type == SHT_NOBITS;
0498 
0499         if (!nobits && sechdrs[i].sh_offset > info->size) {
0500             fatal("%s is truncated. sechdrs[i].sh_offset=%lu > "
0501                   "sizeof(*hrd)=%zu\n", filename,
0502                   (unsigned long)sechdrs[i].sh_offset,
0503                   sizeof(*hdr));
0504             return 0;
0505         }
0506         secname = secstrings + sechdrs[i].sh_name;
0507         if (strcmp(secname, ".modinfo") == 0) {
0508             if (nobits)
0509                 fatal("%s has NOBITS .modinfo\n", filename);
0510             info->modinfo = (void *)hdr + sechdrs[i].sh_offset;
0511             info->modinfo_len = sechdrs[i].sh_size;
0512         } else if (strcmp(secname, "__ksymtab") == 0)
0513             info->export_sec = i;
0514         else if (strcmp(secname, "__ksymtab_unused") == 0)
0515             info->export_unused_sec = i;
0516         else if (strcmp(secname, "__ksymtab_gpl") == 0)
0517             info->export_gpl_sec = i;
0518         else if (strcmp(secname, "__ksymtab_unused_gpl") == 0)
0519             info->export_unused_gpl_sec = i;
0520         else if (strcmp(secname, "__ksymtab_gpl_future") == 0)
0521             info->export_gpl_future_sec = i;
0522 
0523         if (sechdrs[i].sh_type == SHT_SYMTAB) {
0524             unsigned int sh_link_idx;
0525             symtab_idx = i;
0526             info->symtab_start = (void *)hdr +
0527                 sechdrs[i].sh_offset;
0528             info->symtab_stop  = (void *)hdr +
0529                 sechdrs[i].sh_offset + sechdrs[i].sh_size;
0530             sh_link_idx = sechdrs[i].sh_link;
0531             info->strtab       = (void *)hdr +
0532                 sechdrs[sh_link_idx].sh_offset;
0533         }
0534 
0535         /* 32bit section no. table? ("more than 64k sections") */
0536         if (sechdrs[i].sh_type == SHT_SYMTAB_SHNDX) {
0537             symtab_shndx_idx = i;
0538             info->symtab_shndx_start = (void *)hdr +
0539                 sechdrs[i].sh_offset;
0540             info->symtab_shndx_stop  = (void *)hdr +
0541                 sechdrs[i].sh_offset + sechdrs[i].sh_size;
0542         }
0543     }
0544     if (!info->symtab_start)
0545         fatal("%s has no symtab?\n", filename);
0546 
0547     /* Fix endianness in symbols */
0548     for (sym = info->symtab_start; sym < info->symtab_stop; sym++) {
0549         sym->st_shndx = TO_NATIVE(sym->st_shndx);
0550         sym->st_name  = TO_NATIVE(sym->st_name);
0551         sym->st_value = TO_NATIVE(sym->st_value);
0552         sym->st_size  = TO_NATIVE(sym->st_size);
0553     }
0554 
0555     if (symtab_shndx_idx != ~0U) {
0556         Elf32_Word *p;
0557         if (symtab_idx != sechdrs[symtab_shndx_idx].sh_link)
0558             fatal("%s: SYMTAB_SHNDX has bad sh_link: %u!=%u\n",
0559                   filename, sechdrs[symtab_shndx_idx].sh_link,
0560                   symtab_idx);
0561         /* Fix endianness */
0562         for (p = info->symtab_shndx_start; p < info->symtab_shndx_stop;
0563              p++)
0564             *p = TO_NATIVE(*p);
0565     }
0566 
0567     return 1;
0568 }
0569 
0570 static void parse_elf_finish(struct elf_info *info)
0571 {
0572     release_file(info->hdr, info->size);
0573 }
0574 
0575 static int ignore_undef_symbol(struct elf_info *info, const char *symname)
0576 {
0577     /* ignore __this_module, it will be resolved shortly */
0578     if (strcmp(symname, VMLINUX_SYMBOL_STR(__this_module)) == 0)
0579         return 1;
0580     /* ignore global offset table */
0581     if (strcmp(symname, "_GLOBAL_OFFSET_TABLE_") == 0)
0582         return 1;
0583     if (info->hdr->e_machine == EM_PPC)
0584         /* Special register function linked on all modules during final link of .ko */
0585         if (strncmp(symname, "_restgpr_", sizeof("_restgpr_") - 1) == 0 ||
0586             strncmp(symname, "_savegpr_", sizeof("_savegpr_") - 1) == 0 ||
0587             strncmp(symname, "_rest32gpr_", sizeof("_rest32gpr_") - 1) == 0 ||
0588             strncmp(symname, "_save32gpr_", sizeof("_save32gpr_") - 1) == 0 ||
0589             strncmp(symname, "_restvr_", sizeof("_restvr_") - 1) == 0 ||
0590             strncmp(symname, "_savevr_", sizeof("_savevr_") - 1) == 0)
0591             return 1;
0592     if (info->hdr->e_machine == EM_PPC64)
0593         /* Special register function linked on all modules during final link of .ko */
0594         if (strncmp(symname, "_restgpr0_", sizeof("_restgpr0_") - 1) == 0 ||
0595             strncmp(symname, "_savegpr0_", sizeof("_savegpr0_") - 1) == 0 ||
0596             strncmp(symname, "_restvr_", sizeof("_restvr_") - 1) == 0 ||
0597             strncmp(symname, "_savevr_", sizeof("_savevr_") - 1) == 0 ||
0598             strcmp(symname, ".TOC.") == 0)
0599             return 1;
0600     /* Do not ignore this symbol */
0601     return 0;
0602 }
0603 
0604 #define CRC_PFX     VMLINUX_SYMBOL_STR(__crc_)
0605 #define KSYMTAB_PFX VMLINUX_SYMBOL_STR(__ksymtab_)
0606 
0607 static void handle_modversions(struct module *mod, struct elf_info *info,
0608                    Elf_Sym *sym, const char *symname)
0609 {
0610     unsigned int crc;
0611     enum export export;
0612     bool is_crc = false;
0613 
0614     if ((!is_vmlinux(mod->name) || mod->is_dot_o) &&
0615         strncmp(symname, "__ksymtab", 9) == 0)
0616         export = export_from_secname(info, get_secindex(info, sym));
0617     else
0618         export = export_from_sec(info, get_secindex(info, sym));
0619 
0620     /* CRC'd symbol */
0621     if (strncmp(symname, CRC_PFX, strlen(CRC_PFX)) == 0) {
0622         is_crc = true;
0623         crc = (unsigned int) sym->st_value;
0624         if (sym->st_shndx != SHN_UNDEF && sym->st_shndx != SHN_ABS) {
0625             unsigned int *crcp;
0626 
0627             /* symbol points to the CRC in the ELF object */
0628             crcp = (void *)info->hdr + sym->st_value +
0629                    info->sechdrs[sym->st_shndx].sh_offset -
0630                    (info->hdr->e_type != ET_REL ?
0631                 info->sechdrs[sym->st_shndx].sh_addr : 0);
0632             crc = *crcp;
0633         }
0634         sym_update_crc(symname + strlen(CRC_PFX), mod, crc,
0635                 export);
0636     }
0637 
0638     switch (sym->st_shndx) {
0639     case SHN_COMMON:
0640         if (!strncmp(symname, "__gnu_lto_", sizeof("__gnu_lto_")-1)) {
0641             /* Should warn here, but modpost runs before the linker */
0642         } else
0643             warn("\"%s\" [%s] is COMMON symbol\n", symname, mod->name);
0644         break;
0645     case SHN_UNDEF:
0646         /* undefined symbol */
0647         if (ELF_ST_BIND(sym->st_info) != STB_GLOBAL &&
0648             ELF_ST_BIND(sym->st_info) != STB_WEAK)
0649             break;
0650         if (ignore_undef_symbol(info, symname))
0651             break;
0652 /* cope with newer glibc (2.3.4 or higher) STT_ definition in elf.h */
0653 #if defined(STT_REGISTER) || defined(STT_SPARC_REGISTER)
0654 /* add compatibility with older glibc */
0655 #ifndef STT_SPARC_REGISTER
0656 #define STT_SPARC_REGISTER STT_REGISTER
0657 #endif
0658         if (info->hdr->e_machine == EM_SPARC ||
0659             info->hdr->e_machine == EM_SPARCV9) {
0660             /* Ignore register directives. */
0661             if (ELF_ST_TYPE(sym->st_info) == STT_SPARC_REGISTER)
0662                 break;
0663             if (symname[0] == '.') {
0664                 char *munged = strdup(symname);
0665                 munged[0] = '_';
0666                 munged[1] = toupper(munged[1]);
0667                 symname = munged;
0668             }
0669         }
0670 #endif
0671 
0672 #ifdef CONFIG_HAVE_UNDERSCORE_SYMBOL_PREFIX
0673         if (symname[0] != '_')
0674             break;
0675         else
0676             symname++;
0677 #endif
0678         if (is_crc) {
0679             const char *e = is_vmlinux(mod->name) ?"":".ko";
0680             warn("EXPORT symbol \"%s\" [%s%s] version generation failed, symbol will not be versioned.\n", symname + strlen(CRC_PFX), mod->name, e);
0681         }
0682         mod->unres = alloc_symbol(symname,
0683                       ELF_ST_BIND(sym->st_info) == STB_WEAK,
0684                       mod->unres);
0685         break;
0686     default:
0687         /* All exported symbols */
0688         if (strncmp(symname, KSYMTAB_PFX, strlen(KSYMTAB_PFX)) == 0) {
0689             sym_add_exported(symname + strlen(KSYMTAB_PFX), mod,
0690                     export);
0691         }
0692         if (strcmp(symname, VMLINUX_SYMBOL_STR(init_module)) == 0)
0693             mod->has_init = 1;
0694         if (strcmp(symname, VMLINUX_SYMBOL_STR(cleanup_module)) == 0)
0695             mod->has_cleanup = 1;
0696         break;
0697     }
0698 }
0699 
0700 /**
0701  * Parse tag=value strings from .modinfo section
0702  **/
0703 static char *next_string(char *string, unsigned long *secsize)
0704 {
0705     /* Skip non-zero chars */
0706     while (string[0]) {
0707         string++;
0708         if ((*secsize)-- <= 1)
0709             return NULL;
0710     }
0711 
0712     /* Skip any zero padding. */
0713     while (!string[0]) {
0714         string++;
0715         if ((*secsize)-- <= 1)
0716             return NULL;
0717     }
0718     return string;
0719 }
0720 
0721 static char *get_next_modinfo(void *modinfo, unsigned long modinfo_len,
0722                   const char *tag, char *info)
0723 {
0724     char *p;
0725     unsigned int taglen = strlen(tag);
0726     unsigned long size = modinfo_len;
0727 
0728     if (info) {
0729         size -= info - (char *)modinfo;
0730         modinfo = next_string(info, &size);
0731     }
0732 
0733     for (p = modinfo; p; p = next_string(p, &size)) {
0734         if (strncmp(p, tag, taglen) == 0 && p[taglen] == '=')
0735             return p + taglen + 1;
0736     }
0737     return NULL;
0738 }
0739 
0740 static char *get_modinfo(void *modinfo, unsigned long modinfo_len,
0741              const char *tag)
0742 
0743 {
0744     return get_next_modinfo(modinfo, modinfo_len, tag, NULL);
0745 }
0746 
0747 /**
0748  * Test if string s ends in string sub
0749  * return 0 if match
0750  **/
0751 static int strrcmp(const char *s, const char *sub)
0752 {
0753     int slen, sublen;
0754 
0755     if (!s || !sub)
0756         return 1;
0757 
0758     slen = strlen(s);
0759     sublen = strlen(sub);
0760 
0761     if ((slen == 0) || (sublen == 0))
0762         return 1;
0763 
0764     if (sublen > slen)
0765         return 1;
0766 
0767     return memcmp(s + slen - sublen, sub, sublen);
0768 }
0769 
0770 static const char *sym_name(struct elf_info *elf, Elf_Sym *sym)
0771 {
0772     if (sym)
0773         return elf->strtab + sym->st_name;
0774     else
0775         return "(unknown)";
0776 }
0777 
0778 static const char *sec_name(struct elf_info *elf, int secindex)
0779 {
0780     Elf_Shdr *sechdrs = elf->sechdrs;
0781     return (void *)elf->hdr +
0782         elf->sechdrs[elf->secindex_strings].sh_offset +
0783         sechdrs[secindex].sh_name;
0784 }
0785 
0786 static const char *sech_name(struct elf_info *elf, Elf_Shdr *sechdr)
0787 {
0788     return (void *)elf->hdr +
0789         elf->sechdrs[elf->secindex_strings].sh_offset +
0790         sechdr->sh_name;
0791 }
0792 
0793 /* The pattern is an array of simple patterns.
0794  * "foo" will match an exact string equal to "foo"
0795  * "*foo" will match a string that ends with "foo"
0796  * "foo*" will match a string that begins with "foo"
0797  * "*foo*" will match a string that contains "foo"
0798  */
0799 static int match(const char *sym, const char * const pat[])
0800 {
0801     const char *p;
0802     while (*pat) {
0803         p = *pat++;
0804         const char *endp = p + strlen(p) - 1;
0805 
0806         /* "*foo*" */
0807         if (*p == '*' && *endp == '*') {
0808             char *here, *bare = strndup(p + 1, strlen(p) - 2);
0809 
0810             here = strstr(sym, bare);
0811             free(bare);
0812             if (here != NULL)
0813                 return 1;
0814         }
0815         /* "*foo" */
0816         else if (*p == '*') {
0817             if (strrcmp(sym, p + 1) == 0)
0818                 return 1;
0819         }
0820         /* "foo*" */
0821         else if (*endp == '*') {
0822             if (strncmp(sym, p, strlen(p) - 1) == 0)
0823                 return 1;
0824         }
0825         /* no wildcards */
0826         else {
0827             if (strcmp(p, sym) == 0)
0828                 return 1;
0829         }
0830     }
0831     /* no match */
0832     return 0;
0833 }
0834 
0835 /* sections that we do not want to do full section mismatch check on */
0836 static const char *const section_white_list[] =
0837 {
0838     ".comment*",
0839     ".debug*",
0840     ".cranges",     /* sh64 */
0841     ".zdebug*",     /* Compressed debug sections. */
0842     ".GCC-command-line",    /* mn10300 */
0843     ".GCC.command.line",    /* record-gcc-switches, non mn10300 */
0844     ".mdebug*",        /* alpha, score, mips etc. */
0845     ".pdr",            /* alpha, score, mips etc. */
0846     ".stab*",
0847     ".note*",
0848     ".got*",
0849     ".toc*",
0850     ".xt.prop",              /* xtensa */
0851     ".xt.lit",         /* xtensa */
0852     ".arcextmap*",          /* arc */
0853     ".gnu.linkonce.arcext*",    /* arc : modules */
0854     ".cmem*",           /* EZchip */
0855     ".fmt_slot*",           /* EZchip */
0856     ".gnu.lto*",
0857     NULL
0858 };
0859 
0860 /*
0861  * This is used to find sections missing the SHF_ALLOC flag.
0862  * The cause of this is often a section specified in assembler
0863  * without "ax" / "aw".
0864  */
0865 static void check_section(const char *modname, struct elf_info *elf,
0866               Elf_Shdr *sechdr)
0867 {
0868     const char *sec = sech_name(elf, sechdr);
0869 
0870     if (sechdr->sh_type == SHT_PROGBITS &&
0871         !(sechdr->sh_flags & SHF_ALLOC) &&
0872         !match(sec, section_white_list)) {
0873         warn("%s (%s): unexpected non-allocatable section.\n"
0874              "Did you forget to use \"ax\"/\"aw\" in a .S file?\n"
0875              "Note that for example <linux/init.h> contains\n"
0876              "section definitions for use in .S files.\n\n",
0877              modname, sec);
0878     }
0879 }
0880 
0881 
0882 
0883 #define ALL_INIT_DATA_SECTIONS \
0884     ".init.setup", ".init.rodata", ".meminit.rodata", \
0885     ".init.data", ".meminit.data"
0886 #define ALL_EXIT_DATA_SECTIONS \
0887     ".exit.data", ".memexit.data"
0888 
0889 #define ALL_INIT_TEXT_SECTIONS \
0890     ".init.text", ".meminit.text"
0891 #define ALL_EXIT_TEXT_SECTIONS \
0892     ".exit.text", ".memexit.text"
0893 
0894 #define ALL_PCI_INIT_SECTIONS   \
0895     ".pci_fixup_early", ".pci_fixup_header", ".pci_fixup_final", \
0896     ".pci_fixup_enable", ".pci_fixup_resume", \
0897     ".pci_fixup_resume_early", ".pci_fixup_suspend"
0898 
0899 #define ALL_XXXINIT_SECTIONS MEM_INIT_SECTIONS
0900 #define ALL_XXXEXIT_SECTIONS MEM_EXIT_SECTIONS
0901 
0902 #define ALL_INIT_SECTIONS INIT_SECTIONS, ALL_XXXINIT_SECTIONS
0903 #define ALL_EXIT_SECTIONS EXIT_SECTIONS, ALL_XXXEXIT_SECTIONS
0904 
0905 #define DATA_SECTIONS ".data", ".data.rel"
0906 #define TEXT_SECTIONS ".text", ".text.unlikely", ".sched.text", \
0907         ".kprobes.text", ".cpuidle.text"
0908 #define OTHER_TEXT_SECTIONS ".ref.text", ".head.text", ".spinlock.text", \
0909         ".fixup", ".entry.text", ".exception.text", ".text.*", \
0910         ".coldtext"
0911 
0912 #define INIT_SECTIONS      ".init.*"
0913 #define MEM_INIT_SECTIONS  ".meminit.*"
0914 
0915 #define EXIT_SECTIONS      ".exit.*"
0916 #define MEM_EXIT_SECTIONS  ".memexit.*"
0917 
0918 #define ALL_TEXT_SECTIONS  ALL_INIT_TEXT_SECTIONS, ALL_EXIT_TEXT_SECTIONS, \
0919         TEXT_SECTIONS, OTHER_TEXT_SECTIONS
0920 
0921 /* init data sections */
0922 static const char *const init_data_sections[] =
0923     { ALL_INIT_DATA_SECTIONS, NULL };
0924 
0925 /* all init sections */
0926 static const char *const init_sections[] = { ALL_INIT_SECTIONS, NULL };
0927 
0928 /* All init and exit sections (code + data) */
0929 static const char *const init_exit_sections[] =
0930     {ALL_INIT_SECTIONS, ALL_EXIT_SECTIONS, NULL };
0931 
0932 /* all text sections */
0933 static const char *const text_sections[] = { ALL_TEXT_SECTIONS, NULL };
0934 
0935 /* data section */
0936 static const char *const data_sections[] = { DATA_SECTIONS, NULL };
0937 
0938 
0939 /* symbols in .data that may refer to init/exit sections */
0940 #define DEFAULT_SYMBOL_WHITE_LIST                   \
0941     "*driver",                          \
0942     "*_template", /* scsi uses *_template a lot */          \
0943     "*_timer",    /* arm uses ops structures named _timer a lot */  \
0944     "*_sht",      /* scsi also used *_sht to some extent */     \
0945     "*_ops",                            \
0946     "*_probe",                          \
0947     "*_probe_one",                          \
0948     "*_console"
0949 
0950 static const char *const head_sections[] = { ".head.text*", NULL };
0951 static const char *const linker_symbols[] =
0952     { "__init_begin", "_sinittext", "_einittext", NULL };
0953 static const char *const optim_symbols[] = { "*.constprop.*", NULL };
0954 
0955 enum mismatch {
0956     TEXT_TO_ANY_INIT,
0957     DATA_TO_ANY_INIT,
0958     TEXT_TO_ANY_EXIT,
0959     DATA_TO_ANY_EXIT,
0960     XXXINIT_TO_SOME_INIT,
0961     XXXEXIT_TO_SOME_EXIT,
0962     ANY_INIT_TO_ANY_EXIT,
0963     ANY_EXIT_TO_ANY_INIT,
0964     EXPORT_TO_INIT_EXIT,
0965     EXTABLE_TO_NON_TEXT,
0966 };
0967 
0968 /**
0969  * Describe how to match sections on different criterias:
0970  *
0971  * @fromsec: Array of sections to be matched.
0972  *
0973  * @bad_tosec: Relocations applied to a section in @fromsec to a section in
0974  * this array is forbidden (black-list).  Can be empty.
0975  *
0976  * @good_tosec: Relocations applied to a section in @fromsec must be
0977  * targetting sections in this array (white-list).  Can be empty.
0978  *
0979  * @mismatch: Type of mismatch.
0980  *
0981  * @symbol_white_list: Do not match a relocation to a symbol in this list
0982  * even if it is targetting a section in @bad_to_sec.
0983  *
0984  * @handler: Specific handler to call when a match is found.  If NULL,
0985  * default_mismatch_handler() will be called.
0986  *
0987  */
0988 struct sectioncheck {
0989     const char *fromsec[20];
0990     const char *bad_tosec[20];
0991     const char *good_tosec[20];
0992     enum mismatch mismatch;
0993     const char *symbol_white_list[20];
0994     void (*handler)(const char *modname, struct elf_info *elf,
0995             const struct sectioncheck* const mismatch,
0996             Elf_Rela *r, Elf_Sym *sym, const char *fromsec);
0997 
0998 };
0999 
1000 static void extable_mismatch_handler(const char *modname, struct elf_info *elf,
1001                      const struct sectioncheck* const mismatch,
1002                      Elf_Rela *r, Elf_Sym *sym,
1003                      const char *fromsec);
1004 
1005 static const struct sectioncheck sectioncheck[] = {
1006 /* Do not reference init/exit code/data from
1007  * normal code and data
1008  */
1009 {
1010     .fromsec = { TEXT_SECTIONS, NULL },
1011     .bad_tosec = { ALL_INIT_SECTIONS, NULL },
1012     .mismatch = TEXT_TO_ANY_INIT,
1013     .symbol_white_list = { DEFAULT_SYMBOL_WHITE_LIST, NULL },
1014 },
1015 {
1016     .fromsec = { DATA_SECTIONS, NULL },
1017     .bad_tosec = { ALL_XXXINIT_SECTIONS, NULL },
1018     .mismatch = DATA_TO_ANY_INIT,
1019     .symbol_white_list = { DEFAULT_SYMBOL_WHITE_LIST, NULL },
1020 },
1021 {
1022     .fromsec = { DATA_SECTIONS, NULL },
1023     .bad_tosec = { INIT_SECTIONS, NULL },
1024     .mismatch = DATA_TO_ANY_INIT,
1025     .symbol_white_list = {
1026         "*_template", "*_timer", "*_sht", "*_ops",
1027         "*_probe", "*_probe_one", "*_console", NULL
1028     },
1029 },
1030 {
1031     .fromsec = { TEXT_SECTIONS, NULL },
1032     .bad_tosec = { ALL_EXIT_SECTIONS, NULL },
1033     .mismatch = TEXT_TO_ANY_EXIT,
1034     .symbol_white_list = { DEFAULT_SYMBOL_WHITE_LIST, NULL },
1035 },
1036 {
1037     .fromsec = { DATA_SECTIONS, NULL },
1038     .bad_tosec = { ALL_EXIT_SECTIONS, NULL },
1039     .mismatch = DATA_TO_ANY_EXIT,
1040     .symbol_white_list = { DEFAULT_SYMBOL_WHITE_LIST, NULL },
1041 },
1042 /* Do not reference init code/data from meminit code/data */
1043 {
1044     .fromsec = { ALL_XXXINIT_SECTIONS, NULL },
1045     .bad_tosec = { INIT_SECTIONS, NULL },
1046     .mismatch = XXXINIT_TO_SOME_INIT,
1047     .symbol_white_list = { DEFAULT_SYMBOL_WHITE_LIST, NULL },
1048 },
1049 /* Do not reference exit code/data from memexit code/data */
1050 {
1051     .fromsec = { ALL_XXXEXIT_SECTIONS, NULL },
1052     .bad_tosec = { EXIT_SECTIONS, NULL },
1053     .mismatch = XXXEXIT_TO_SOME_EXIT,
1054     .symbol_white_list = { DEFAULT_SYMBOL_WHITE_LIST, NULL },
1055 },
1056 /* Do not use exit code/data from init code */
1057 {
1058     .fromsec = { ALL_INIT_SECTIONS, NULL },
1059     .bad_tosec = { ALL_EXIT_SECTIONS, NULL },
1060     .mismatch = ANY_INIT_TO_ANY_EXIT,
1061     .symbol_white_list = { DEFAULT_SYMBOL_WHITE_LIST, NULL },
1062 },
1063 /* Do not use init code/data from exit code */
1064 {
1065     .fromsec = { ALL_EXIT_SECTIONS, NULL },
1066     .bad_tosec = { ALL_INIT_SECTIONS, NULL },
1067     .mismatch = ANY_EXIT_TO_ANY_INIT,
1068     .symbol_white_list = { DEFAULT_SYMBOL_WHITE_LIST, NULL },
1069 },
1070 {
1071     .fromsec = { ALL_PCI_INIT_SECTIONS, NULL },
1072     .bad_tosec = { INIT_SECTIONS, NULL },
1073     .mismatch = ANY_INIT_TO_ANY_EXIT,
1074     .symbol_white_list = { NULL },
1075 },
1076 /* Do not export init/exit functions or data */
1077 {
1078     .fromsec = { "__ksymtab*", NULL },
1079     .bad_tosec = { INIT_SECTIONS, EXIT_SECTIONS, NULL },
1080     .mismatch = EXPORT_TO_INIT_EXIT,
1081     .symbol_white_list = { DEFAULT_SYMBOL_WHITE_LIST, NULL },
1082 },
1083 {
1084     .fromsec = { "__ex_table", NULL },
1085     /* If you're adding any new black-listed sections in here, consider
1086      * adding a special 'printer' for them in scripts/check_extable.
1087      */
1088     .bad_tosec = { ".altinstr_replacement", NULL },
1089     .good_tosec = {ALL_TEXT_SECTIONS , NULL},
1090     .mismatch = EXTABLE_TO_NON_TEXT,
1091     .handler = extable_mismatch_handler,
1092 }
1093 };
1094 
1095 static const struct sectioncheck *section_mismatch(
1096         const char *fromsec, const char *tosec)
1097 {
1098     int i;
1099     int elems = sizeof(sectioncheck) / sizeof(struct sectioncheck);
1100     const struct sectioncheck *check = &sectioncheck[0];
1101 
1102     /*
1103      * The target section could be the SHT_NUL section when we're
1104      * handling relocations to un-resolved symbols, trying to match it
1105      * doesn't make much sense and causes build failures on parisc and
1106      * mn10300 architectures.
1107      */
1108     if (*tosec == '\0')
1109         return NULL;
1110 
1111     for (i = 0; i < elems; i++) {
1112         if (match(fromsec, check->fromsec)) {
1113             if (check->bad_tosec[0] && match(tosec, check->bad_tosec))
1114                 return check;
1115             if (check->good_tosec[0] && !match(tosec, check->good_tosec))
1116                 return check;
1117         }
1118         check++;
1119     }
1120     return NULL;
1121 }
1122 
1123 /**
1124  * Whitelist to allow certain references to pass with no warning.
1125  *
1126  * Pattern 1:
1127  *   If a module parameter is declared __initdata and permissions=0
1128  *   then this is legal despite the warning generated.
1129  *   We cannot see value of permissions here, so just ignore
1130  *   this pattern.
1131  *   The pattern is identified by:
1132  *   tosec   = .init.data
1133  *   fromsec = .data*
1134  *   atsym   =__param*
1135  *
1136  * Pattern 1a:
1137  *   module_param_call() ops can refer to __init set function if permissions=0
1138  *   The pattern is identified by:
1139  *   tosec   = .init.text
1140  *   fromsec = .data*
1141  *   atsym   = __param_ops_*
1142  *
1143  * Pattern 2:
1144  *   Many drivers utilise a *driver container with references to
1145  *   add, remove, probe functions etc.
1146  *   the pattern is identified by:
1147  *   tosec   = init or exit section
1148  *   fromsec = data section
1149  *   atsym = *driver, *_template, *_sht, *_ops, *_probe,
1150  *           *probe_one, *_console, *_timer
1151  *
1152  * Pattern 3:
1153  *   Whitelist all references from .head.text to any init section
1154  *
1155  * Pattern 4:
1156  *   Some symbols belong to init section but still it is ok to reference
1157  *   these from non-init sections as these symbols don't have any memory
1158  *   allocated for them and symbol address and value are same. So even
1159  *   if init section is freed, its ok to reference those symbols.
1160  *   For ex. symbols marking the init section boundaries.
1161  *   This pattern is identified by
1162  *   refsymname = __init_begin, _sinittext, _einittext
1163  *
1164  * Pattern 5:
1165  *   GCC may optimize static inlines when fed constant arg(s) resulting
1166  *   in functions like cpumask_empty() -- generating an associated symbol
1167  *   cpumask_empty.constprop.3 that appears in the audit.  If the const that
1168  *   is passed in comes from __init, like say nmi_ipi_mask, we get a
1169  *   meaningless section warning.  May need to add isra symbols too...
1170  *   This pattern is identified by
1171  *   tosec   = init section
1172  *   fromsec = text section
1173  *   refsymname = *.constprop.*
1174  *
1175  **/
1176 static int secref_whitelist(const struct sectioncheck *mismatch,
1177                 const char *fromsec, const char *fromsym,
1178                 const char *tosec, const char *tosym)
1179 {
1180     /* Check for pattern 1 */
1181     if (match(tosec, init_data_sections) &&
1182         match(fromsec, data_sections) &&
1183         (strncmp(fromsym, "__param", strlen("__param")) == 0))
1184         return 0;
1185 
1186     /* Check for pattern 1a */
1187     if (strcmp(tosec, ".init.text") == 0 &&
1188         match(fromsec, data_sections) &&
1189         (strncmp(fromsym, "__param_ops_", strlen("__param_ops_")) == 0))
1190         return 0;
1191 
1192     /* Check for pattern 2 */
1193     if (match(tosec, init_exit_sections) &&
1194         match(fromsec, data_sections) &&
1195         match(fromsym, mismatch->symbol_white_list))
1196         return 0;
1197 
1198     /* Check for pattern 3 */
1199     if (match(fromsec, head_sections) &&
1200         match(tosec, init_sections))
1201         return 0;
1202 
1203     /* Check for pattern 4 */
1204     if (match(tosym, linker_symbols))
1205         return 0;
1206 
1207     /* Check for pattern 5 */
1208     if (match(fromsec, text_sections) &&
1209         match(tosec, init_sections) &&
1210         match(fromsym, optim_symbols))
1211         return 0;
1212 
1213     return 1;
1214 }
1215 
1216 /**
1217  * Find symbol based on relocation record info.
1218  * In some cases the symbol supplied is a valid symbol so
1219  * return refsym. If st_name != 0 we assume this is a valid symbol.
1220  * In other cases the symbol needs to be looked up in the symbol table
1221  * based on section and address.
1222  *  **/
1223 static Elf_Sym *find_elf_symbol(struct elf_info *elf, Elf64_Sword addr,
1224                 Elf_Sym *relsym)
1225 {
1226     Elf_Sym *sym;
1227     Elf_Sym *near = NULL;
1228     Elf64_Sword distance = 20;
1229     Elf64_Sword d;
1230     unsigned int relsym_secindex;
1231 
1232     if (relsym->st_name != 0)
1233         return relsym;
1234 
1235     relsym_secindex = get_secindex(elf, relsym);
1236     for (sym = elf->symtab_start; sym < elf->symtab_stop; sym++) {
1237         if (get_secindex(elf, sym) != relsym_secindex)
1238             continue;
1239         if (ELF_ST_TYPE(sym->st_info) == STT_SECTION)
1240             continue;
1241         if (sym->st_value == addr)
1242             return sym;
1243         /* Find a symbol nearby - addr are maybe negative */
1244         d = sym->st_value - addr;
1245         if (d < 0)
1246             d = addr - sym->st_value;
1247         if (d < distance) {
1248             distance = d;
1249             near = sym;
1250         }
1251     }
1252     /* We need a close match */
1253     if (distance < 20)
1254         return near;
1255     else
1256         return NULL;
1257 }
1258 
1259 static inline int is_arm_mapping_symbol(const char *str)
1260 {
1261     return str[0] == '$' && strchr("axtd", str[1])
1262            && (str[2] == '\0' || str[2] == '.');
1263 }
1264 
1265 /*
1266  * If there's no name there, ignore it; likewise, ignore it if it's
1267  * one of the magic symbols emitted used by current ARM tools.
1268  *
1269  * Otherwise if find_symbols_between() returns those symbols, they'll
1270  * fail the whitelist tests and cause lots of false alarms ... fixable
1271  * only by merging __exit and __init sections into __text, bloating
1272  * the kernel (which is especially evil on embedded platforms).
1273  */
1274 static inline int is_valid_name(struct elf_info *elf, Elf_Sym *sym)
1275 {
1276     const char *name = elf->strtab + sym->st_name;
1277 
1278     if (!name || !strlen(name))
1279         return 0;
1280     return !is_arm_mapping_symbol(name);
1281 }
1282 
1283 /*
1284  * Find symbols before or equal addr and after addr - in the section sec.
1285  * If we find two symbols with equal offset prefer one with a valid name.
1286  * The ELF format may have a better way to detect what type of symbol
1287  * it is, but this works for now.
1288  **/
1289 static Elf_Sym *find_elf_symbol2(struct elf_info *elf, Elf_Addr addr,
1290                  const char *sec)
1291 {
1292     Elf_Sym *sym;
1293     Elf_Sym *near = NULL;
1294     Elf_Addr distance = ~0;
1295 
1296     for (sym = elf->symtab_start; sym < elf->symtab_stop; sym++) {
1297         const char *symsec;
1298 
1299         if (is_shndx_special(sym->st_shndx))
1300             continue;
1301         symsec = sec_name(elf, get_secindex(elf, sym));
1302         if (strcmp(symsec, sec) != 0)
1303             continue;
1304         if (!is_valid_name(elf, sym))
1305             continue;
1306         if (sym->st_value <= addr) {
1307             if ((addr - sym->st_value) < distance) {
1308                 distance = addr - sym->st_value;
1309                 near = sym;
1310             } else if ((addr - sym->st_value) == distance) {
1311                 near = sym;
1312             }
1313         }
1314     }
1315     return near;
1316 }
1317 
1318 /*
1319  * Convert a section name to the function/data attribute
1320  * .init.text => __init
1321  * .memexitconst => __memconst
1322  * etc.
1323  *
1324  * The memory of returned value has been allocated on a heap. The user of this
1325  * method should free it after usage.
1326 */
1327 static char *sec2annotation(const char *s)
1328 {
1329     if (match(s, init_exit_sections)) {
1330         char *p = malloc(20);
1331         char *r = p;
1332 
1333         *p++ = '_';
1334         *p++ = '_';
1335         if (*s == '.')
1336             s++;
1337         while (*s && *s != '.')
1338             *p++ = *s++;
1339         *p = '\0';
1340         if (*s == '.')
1341             s++;
1342         if (strstr(s, "rodata") != NULL)
1343             strcat(p, "const ");
1344         else if (strstr(s, "data") != NULL)
1345             strcat(p, "data ");
1346         else
1347             strcat(p, " ");
1348         return r;
1349     } else {
1350         return strdup("");
1351     }
1352 }
1353 
1354 static int is_function(Elf_Sym *sym)
1355 {
1356     if (sym)
1357         return ELF_ST_TYPE(sym->st_info) == STT_FUNC;
1358     else
1359         return -1;
1360 }
1361 
1362 static void print_section_list(const char * const list[20])
1363 {
1364     const char *const *s = list;
1365 
1366     while (*s) {
1367         fprintf(stderr, "%s", *s);
1368         s++;
1369         if (*s)
1370             fprintf(stderr, ", ");
1371     }
1372     fprintf(stderr, "\n");
1373 }
1374 
1375 static inline void get_pretty_name(int is_func, const char** name, const char** name_p)
1376 {
1377     switch (is_func) {
1378     case 0: *name = "variable"; *name_p = ""; break;
1379     case 1: *name = "function"; *name_p = "()"; break;
1380     default: *name = "(unknown reference)"; *name_p = ""; break;
1381     }
1382 }
1383 
1384 /*
1385  * Print a warning about a section mismatch.
1386  * Try to find symbols near it so user can find it.
1387  * Check whitelist before warning - it may be a false positive.
1388  */
1389 static void report_sec_mismatch(const char *modname,
1390                 const struct sectioncheck *mismatch,
1391                 const char *fromsec,
1392                 unsigned long long fromaddr,
1393                 const char *fromsym,
1394                 int from_is_func,
1395                 const char *tosec, const char *tosym,
1396                 int to_is_func)
1397 {
1398     const char *from, *from_p;
1399     const char *to, *to_p;
1400     char *prl_from;
1401     char *prl_to;
1402 
1403     sec_mismatch_count++;
1404     if (!sec_mismatch_verbose)
1405         return;
1406 
1407     get_pretty_name(from_is_func, &from, &from_p);
1408     get_pretty_name(to_is_func, &to, &to_p);
1409 
1410     warn("%s(%s+0x%llx): Section mismatch in reference from the %s %s%s "
1411          "to the %s %s:%s%s\n",
1412          modname, fromsec, fromaddr, from, fromsym, from_p, to, tosec,
1413          tosym, to_p);
1414 
1415     switch (mismatch->mismatch) {
1416     case TEXT_TO_ANY_INIT:
1417         prl_from = sec2annotation(fromsec);
1418         prl_to = sec2annotation(tosec);
1419         fprintf(stderr,
1420         "The function %s%s() references\n"
1421         "the %s %s%s%s.\n"
1422         "This is often because %s lacks a %s\n"
1423         "annotation or the annotation of %s is wrong.\n",
1424         prl_from, fromsym,
1425         to, prl_to, tosym, to_p,
1426         fromsym, prl_to, tosym);
1427         free(prl_from);
1428         free(prl_to);
1429         break;
1430     case DATA_TO_ANY_INIT: {
1431         prl_to = sec2annotation(tosec);
1432         fprintf(stderr,
1433         "The variable %s references\n"
1434         "the %s %s%s%s\n"
1435         "If the reference is valid then annotate the\n"
1436         "variable with __init* or __refdata (see linux/init.h) "
1437         "or name the variable:\n",
1438         fromsym, to, prl_to, tosym, to_p);
1439         print_section_list(mismatch->symbol_white_list);
1440         free(prl_to);
1441         break;
1442     }
1443     case TEXT_TO_ANY_EXIT:
1444         prl_to = sec2annotation(tosec);
1445         fprintf(stderr,
1446         "The function %s() references a %s in an exit section.\n"
1447         "Often the %s %s%s has valid usage outside the exit section\n"
1448         "and the fix is to remove the %sannotation of %s.\n",
1449         fromsym, to, to, tosym, to_p, prl_to, tosym);
1450         free(prl_to);
1451         break;
1452     case DATA_TO_ANY_EXIT: {
1453         prl_to = sec2annotation(tosec);
1454         fprintf(stderr,
1455         "The variable %s references\n"
1456         "the %s %s%s%s\n"
1457         "If the reference is valid then annotate the\n"
1458         "variable with __exit* (see linux/init.h) or "
1459         "name the variable:\n",
1460         fromsym, to, prl_to, tosym, to_p);
1461         print_section_list(mismatch->symbol_white_list);
1462         free(prl_to);
1463         break;
1464     }
1465     case XXXINIT_TO_SOME_INIT:
1466     case XXXEXIT_TO_SOME_EXIT:
1467         prl_from = sec2annotation(fromsec);
1468         prl_to = sec2annotation(tosec);
1469         fprintf(stderr,
1470         "The %s %s%s%s references\n"
1471         "a %s %s%s%s.\n"
1472         "If %s is only used by %s then\n"
1473         "annotate %s with a matching annotation.\n",
1474         from, prl_from, fromsym, from_p,
1475         to, prl_to, tosym, to_p,
1476         tosym, fromsym, tosym);
1477         free(prl_from);
1478         free(prl_to);
1479         break;
1480     case ANY_INIT_TO_ANY_EXIT:
1481         prl_from = sec2annotation(fromsec);
1482         prl_to = sec2annotation(tosec);
1483         fprintf(stderr,
1484         "The %s %s%s%s references\n"
1485         "a %s %s%s%s.\n"
1486         "This is often seen when error handling "
1487         "in the init function\n"
1488         "uses functionality in the exit path.\n"
1489         "The fix is often to remove the %sannotation of\n"
1490         "%s%s so it may be used outside an exit section.\n",
1491         from, prl_from, fromsym, from_p,
1492         to, prl_to, tosym, to_p,
1493         prl_to, tosym, to_p);
1494         free(prl_from);
1495         free(prl_to);
1496         break;
1497     case ANY_EXIT_TO_ANY_INIT:
1498         prl_from = sec2annotation(fromsec);
1499         prl_to = sec2annotation(tosec);
1500         fprintf(stderr,
1501         "The %s %s%s%s references\n"
1502         "a %s %s%s%s.\n"
1503         "This is often seen when error handling "
1504         "in the exit function\n"
1505         "uses functionality in the init path.\n"
1506         "The fix is often to remove the %sannotation of\n"
1507         "%s%s so it may be used outside an init section.\n",
1508         from, prl_from, fromsym, from_p,
1509         to, prl_to, tosym, to_p,
1510         prl_to, tosym, to_p);
1511         free(prl_from);
1512         free(prl_to);
1513         break;
1514     case EXPORT_TO_INIT_EXIT:
1515         prl_to = sec2annotation(tosec);
1516         fprintf(stderr,
1517         "The symbol %s is exported and annotated %s\n"
1518         "Fix this by removing the %sannotation of %s "
1519         "or drop the export.\n",
1520         tosym, prl_to, prl_to, tosym);
1521         free(prl_to);
1522         break;
1523     case EXTABLE_TO_NON_TEXT:
1524         fatal("There's a special handler for this mismatch type, "
1525               "we should never get here.");
1526         break;
1527     }
1528     fprintf(stderr, "\n");
1529 }
1530 
1531 static void default_mismatch_handler(const char *modname, struct elf_info *elf,
1532                      const struct sectioncheck* const mismatch,
1533                      Elf_Rela *r, Elf_Sym *sym, const char *fromsec)
1534 {
1535     const char *tosec;
1536     Elf_Sym *to;
1537     Elf_Sym *from;
1538     const char *tosym;
1539     const char *fromsym;
1540 
1541     from = find_elf_symbol2(elf, r->r_offset, fromsec);
1542     fromsym = sym_name(elf, from);
1543 
1544     if (!strncmp(fromsym, "reference___initcall",
1545              sizeof("reference___initcall")-1))
1546         return;
1547 
1548     tosec = sec_name(elf, get_secindex(elf, sym));
1549     to = find_elf_symbol(elf, r->r_addend, sym);
1550     tosym = sym_name(elf, to);
1551 
1552     /* check whitelist - we may ignore it */
1553     if (secref_whitelist(mismatch,
1554                  fromsec, fromsym, tosec, tosym)) {
1555         report_sec_mismatch(modname, mismatch,
1556                     fromsec, r->r_offset, fromsym,
1557                     is_function(from), tosec, tosym,
1558                     is_function(to));
1559     }
1560 }
1561 
1562 static int is_executable_section(struct elf_info* elf, unsigned int section_index)
1563 {
1564     if (section_index > elf->num_sections)
1565         fatal("section_index is outside elf->num_sections!\n");
1566 
1567     return ((elf->sechdrs[section_index].sh_flags & SHF_EXECINSTR) == SHF_EXECINSTR);
1568 }
1569 
1570 /*
1571  * We rely on a gross hack in section_rel[a]() calling find_extable_entry_size()
1572  * to know the sizeof(struct exception_table_entry) for the target architecture.
1573  */
1574 static unsigned int extable_entry_size = 0;
1575 static void find_extable_entry_size(const char* const sec, const Elf_Rela* r)
1576 {
1577     /*
1578      * If we're currently checking the second relocation within __ex_table,
1579      * that relocation offset tells us the offsetof(struct
1580      * exception_table_entry, fixup) which is equal to sizeof(struct
1581      * exception_table_entry) divided by two.  We use that to our advantage
1582      * since there's no portable way to get that size as every architecture
1583      * seems to go with different sized types.  Not pretty but better than
1584      * hard-coding the size for every architecture..
1585      */
1586     if (!extable_entry_size)
1587         extable_entry_size = r->r_offset * 2;
1588 }
1589 
1590 static inline bool is_extable_fault_address(Elf_Rela *r)
1591 {
1592     /*
1593      * extable_entry_size is only discovered after we've handled the
1594      * _second_ relocation in __ex_table, so only abort when we're not
1595      * handling the first reloc and extable_entry_size is zero.
1596      */
1597     if (r->r_offset && extable_entry_size == 0)
1598         fatal("extable_entry size hasn't been discovered!\n");
1599 
1600     return ((r->r_offset == 0) ||
1601         (r->r_offset % extable_entry_size == 0));
1602 }
1603 
1604 #define is_second_extable_reloc(Start, Cur, Sec)            \
1605     (((Cur) == (Start) + 1) && (strcmp("__ex_table", (Sec)) == 0))
1606 
1607 static void report_extable_warnings(const char* modname, struct elf_info* elf,
1608                     const struct sectioncheck* const mismatch,
1609                     Elf_Rela* r, Elf_Sym* sym,
1610                     const char* fromsec, const char* tosec)
1611 {
1612     Elf_Sym* fromsym = find_elf_symbol2(elf, r->r_offset, fromsec);
1613     const char* fromsym_name = sym_name(elf, fromsym);
1614     Elf_Sym* tosym = find_elf_symbol(elf, r->r_addend, sym);
1615     const char* tosym_name = sym_name(elf, tosym);
1616     const char* from_pretty_name;
1617     const char* from_pretty_name_p;
1618     const char* to_pretty_name;
1619     const char* to_pretty_name_p;
1620 
1621     get_pretty_name(is_function(fromsym),
1622             &from_pretty_name, &from_pretty_name_p);
1623     get_pretty_name(is_function(tosym),
1624             &to_pretty_name, &to_pretty_name_p);
1625 
1626     warn("%s(%s+0x%lx): Section mismatch in reference"
1627          " from the %s %s%s to the %s %s:%s%s\n",
1628          modname, fromsec, (long)r->r_offset, from_pretty_name,
1629          fromsym_name, from_pretty_name_p,
1630          to_pretty_name, tosec, tosym_name, to_pretty_name_p);
1631 
1632     if (!match(tosec, mismatch->bad_tosec) &&
1633         is_executable_section(elf, get_secindex(elf, sym)))
1634         fprintf(stderr,
1635             "The relocation at %s+0x%lx references\n"
1636             "section \"%s\" which is not in the list of\n"
1637             "authorized sections.  If you're adding a new section\n"
1638             "and/or if this reference is valid, add \"%s\" to the\n"
1639             "list of authorized sections to jump to on fault.\n"
1640             "This can be achieved by adding \"%s\" to \n"
1641             "OTHER_TEXT_SECTIONS in scripts/mod/modpost.c.\n",
1642             fromsec, (long)r->r_offset, tosec, tosec, tosec);
1643 }
1644 
1645 static void extable_mismatch_handler(const char* modname, struct elf_info *elf,
1646                      const struct sectioncheck* const mismatch,
1647                      Elf_Rela* r, Elf_Sym* sym,
1648                      const char *fromsec)
1649 {
1650     const char* tosec = sec_name(elf, get_secindex(elf, sym));
1651 
1652     sec_mismatch_count++;
1653 
1654     if (sec_mismatch_verbose)
1655         report_extable_warnings(modname, elf, mismatch, r, sym,
1656                     fromsec, tosec);
1657 
1658     if (match(tosec, mismatch->bad_tosec))
1659         fatal("The relocation at %s+0x%lx references\n"
1660               "section \"%s\" which is black-listed.\n"
1661               "Something is seriously wrong and should be fixed.\n"
1662               "You might get more information about where this is\n"
1663               "coming from by using scripts/check_extable.sh %s\n",
1664               fromsec, (long)r->r_offset, tosec, modname);
1665     else if (!is_executable_section(elf, get_secindex(elf, sym))) {
1666         if (is_extable_fault_address(r))
1667             fatal("The relocation at %s+0x%lx references\n"
1668                   "section \"%s\" which is not executable, IOW\n"
1669                   "it is not possible for the kernel to fault\n"
1670                   "at that address.  Something is seriously wrong\n"
1671                   "and should be fixed.\n",
1672                   fromsec, (long)r->r_offset, tosec);
1673         else
1674             fatal("The relocation at %s+0x%lx references\n"
1675                   "section \"%s\" which is not executable, IOW\n"
1676                   "the kernel will fault if it ever tries to\n"
1677                   "jump to it.  Something is seriously wrong\n"
1678                   "and should be fixed.\n",
1679                   fromsec, (long)r->r_offset, tosec);
1680     }
1681 }
1682 
1683 static void check_section_mismatch(const char *modname, struct elf_info *elf,
1684                    Elf_Rela *r, Elf_Sym *sym, const char *fromsec)
1685 {
1686     const char *tosec = sec_name(elf, get_secindex(elf, sym));;
1687     const struct sectioncheck *mismatch = section_mismatch(fromsec, tosec);
1688 
1689     if (mismatch) {
1690         if (mismatch->handler)
1691             mismatch->handler(modname, elf,  mismatch,
1692                       r, sym, fromsec);
1693         else
1694             default_mismatch_handler(modname, elf, mismatch,
1695                          r, sym, fromsec);
1696     }
1697 }
1698 
1699 static unsigned int *reloc_location(struct elf_info *elf,
1700                     Elf_Shdr *sechdr, Elf_Rela *r)
1701 {
1702     Elf_Shdr *sechdrs = elf->sechdrs;
1703     int section = sechdr->sh_info;
1704 
1705     return (void *)elf->hdr + sechdrs[section].sh_offset +
1706         r->r_offset;
1707 }
1708 
1709 static int addend_386_rel(struct elf_info *elf, Elf_Shdr *sechdr, Elf_Rela *r)
1710 {
1711     unsigned int r_typ = ELF_R_TYPE(r->r_info);
1712     unsigned int *location = reloc_location(elf, sechdr, r);
1713 
1714     switch (r_typ) {
1715     case R_386_32:
1716         r->r_addend = TO_NATIVE(*location);
1717         break;
1718     case R_386_PC32:
1719         r->r_addend = TO_NATIVE(*location) + 4;
1720         /* For CONFIG_RELOCATABLE=y */
1721         if (elf->hdr->e_type == ET_EXEC)
1722             r->r_addend += r->r_offset;
1723         break;
1724     }
1725     return 0;
1726 }
1727 
1728 #ifndef R_ARM_CALL
1729 #define R_ARM_CALL  28
1730 #endif
1731 #ifndef R_ARM_JUMP24
1732 #define R_ARM_JUMP24    29
1733 #endif
1734 
1735 #ifndef R_ARM_THM_CALL
1736 #define R_ARM_THM_CALL      10
1737 #endif
1738 #ifndef R_ARM_THM_JUMP24
1739 #define R_ARM_THM_JUMP24    30
1740 #endif
1741 #ifndef R_ARM_THM_JUMP19
1742 #define R_ARM_THM_JUMP19    51
1743 #endif
1744 
1745 static int addend_arm_rel(struct elf_info *elf, Elf_Shdr *sechdr, Elf_Rela *r)
1746 {
1747     unsigned int r_typ = ELF_R_TYPE(r->r_info);
1748 
1749     switch (r_typ) {
1750     case R_ARM_ABS32:
1751         /* From ARM ABI: (S + A) | T */
1752         r->r_addend = (int)(long)
1753                   (elf->symtab_start + ELF_R_SYM(r->r_info));
1754         break;
1755     case R_ARM_PC24:
1756     case R_ARM_CALL:
1757     case R_ARM_JUMP24:
1758     case R_ARM_THM_CALL:
1759     case R_ARM_THM_JUMP24:
1760     case R_ARM_THM_JUMP19:
1761         /* From ARM ABI: ((S + A) | T) - P */
1762         r->r_addend = (int)(long)(elf->hdr +
1763                   sechdr->sh_offset +
1764                   (r->r_offset - sechdr->sh_addr));
1765         break;
1766     default:
1767         return 1;
1768     }
1769     return 0;
1770 }
1771 
1772 static int addend_mips_rel(struct elf_info *elf, Elf_Shdr *sechdr, Elf_Rela *r)
1773 {
1774     unsigned int r_typ = ELF_R_TYPE(r->r_info);
1775     unsigned int *location = reloc_location(elf, sechdr, r);
1776     unsigned int inst;
1777 
1778     if (r_typ == R_MIPS_HI16)
1779         return 1;   /* skip this */
1780     inst = TO_NATIVE(*location);
1781     switch (r_typ) {
1782     case R_MIPS_LO16:
1783         r->r_addend = inst & 0xffff;
1784         break;
1785     case R_MIPS_26:
1786         r->r_addend = (inst & 0x03ffffff) << 2;
1787         break;
1788     case R_MIPS_32:
1789         r->r_addend = inst;
1790         break;
1791     }
1792     return 0;
1793 }
1794 
1795 static void section_rela(const char *modname, struct elf_info *elf,
1796              Elf_Shdr *sechdr)
1797 {
1798     Elf_Sym  *sym;
1799     Elf_Rela *rela;
1800     Elf_Rela r;
1801     unsigned int r_sym;
1802     const char *fromsec;
1803 
1804     Elf_Rela *start = (void *)elf->hdr + sechdr->sh_offset;
1805     Elf_Rela *stop  = (void *)start + sechdr->sh_size;
1806 
1807     fromsec = sech_name(elf, sechdr);
1808     fromsec += strlen(".rela");
1809     /* if from section (name) is know good then skip it */
1810     if (match(fromsec, section_white_list))
1811         return;
1812 
1813     for (rela = start; rela < stop; rela++) {
1814         r.r_offset = TO_NATIVE(rela->r_offset);
1815 #if KERNEL_ELFCLASS == ELFCLASS64
1816         if (elf->hdr->e_machine == EM_MIPS) {
1817             unsigned int r_typ;
1818             r_sym = ELF64_MIPS_R_SYM(rela->r_info);
1819             r_sym = TO_NATIVE(r_sym);
1820             r_typ = ELF64_MIPS_R_TYPE(rela->r_info);
1821             r.r_info = ELF64_R_INFO(r_sym, r_typ);
1822         } else {
1823             r.r_info = TO_NATIVE(rela->r_info);
1824             r_sym = ELF_R_SYM(r.r_info);
1825         }
1826 #else
1827         r.r_info = TO_NATIVE(rela->r_info);
1828         r_sym = ELF_R_SYM(r.r_info);
1829 #endif
1830         r.r_addend = TO_NATIVE(rela->r_addend);
1831         sym = elf->symtab_start + r_sym;
1832         /* Skip special sections */
1833         if (is_shndx_special(sym->st_shndx))
1834             continue;
1835         if (is_second_extable_reloc(start, rela, fromsec))
1836             find_extable_entry_size(fromsec, &r);
1837         check_section_mismatch(modname, elf, &r, sym, fromsec);
1838     }
1839 }
1840 
1841 static void section_rel(const char *modname, struct elf_info *elf,
1842             Elf_Shdr *sechdr)
1843 {
1844     Elf_Sym *sym;
1845     Elf_Rel *rel;
1846     Elf_Rela r;
1847     unsigned int r_sym;
1848     const char *fromsec;
1849 
1850     Elf_Rel *start = (void *)elf->hdr + sechdr->sh_offset;
1851     Elf_Rel *stop  = (void *)start + sechdr->sh_size;
1852 
1853     fromsec = sech_name(elf, sechdr);
1854     fromsec += strlen(".rel");
1855     /* if from section (name) is know good then skip it */
1856     if (match(fromsec, section_white_list))
1857         return;
1858 
1859     for (rel = start; rel < stop; rel++) {
1860         r.r_offset = TO_NATIVE(rel->r_offset);
1861 #if KERNEL_ELFCLASS == ELFCLASS64
1862         if (elf->hdr->e_machine == EM_MIPS) {
1863             unsigned int r_typ;
1864             r_sym = ELF64_MIPS_R_SYM(rel->r_info);
1865             r_sym = TO_NATIVE(r_sym);
1866             r_typ = ELF64_MIPS_R_TYPE(rel->r_info);
1867             r.r_info = ELF64_R_INFO(r_sym, r_typ);
1868         } else {
1869             r.r_info = TO_NATIVE(rel->r_info);
1870             r_sym = ELF_R_SYM(r.r_info);
1871         }
1872 #else
1873         r.r_info = TO_NATIVE(rel->r_info);
1874         r_sym = ELF_R_SYM(r.r_info);
1875 #endif
1876         r.r_addend = 0;
1877         switch (elf->hdr->e_machine) {
1878         case EM_386:
1879             if (addend_386_rel(elf, sechdr, &r))
1880                 continue;
1881             break;
1882         case EM_ARM:
1883             if (addend_arm_rel(elf, sechdr, &r))
1884                 continue;
1885             break;
1886         case EM_MIPS:
1887             if (addend_mips_rel(elf, sechdr, &r))
1888                 continue;
1889             break;
1890         }
1891         sym = elf->symtab_start + r_sym;
1892         /* Skip special sections */
1893         if (is_shndx_special(sym->st_shndx))
1894             continue;
1895         if (is_second_extable_reloc(start, rel, fromsec))
1896             find_extable_entry_size(fromsec, &r);
1897         check_section_mismatch(modname, elf, &r, sym, fromsec);
1898     }
1899 }
1900 
1901 /**
1902  * A module includes a number of sections that are discarded
1903  * either when loaded or when used as built-in.
1904  * For loaded modules all functions marked __init and all data
1905  * marked __initdata will be discarded when the module has been initialized.
1906  * Likewise for modules used built-in the sections marked __exit
1907  * are discarded because __exit marked function are supposed to be called
1908  * only when a module is unloaded which never happens for built-in modules.
1909  * The check_sec_ref() function traverses all relocation records
1910  * to find all references to a section that reference a section that will
1911  * be discarded and warns about it.
1912  **/
1913 static void check_sec_ref(struct module *mod, const char *modname,
1914               struct elf_info *elf)
1915 {
1916     int i;
1917     Elf_Shdr *sechdrs = elf->sechdrs;
1918 
1919     /* Walk through all sections */
1920     for (i = 0; i < elf->num_sections; i++) {
1921         check_section(modname, elf, &elf->sechdrs[i]);
1922         /* We want to process only relocation sections and not .init */
1923         if (sechdrs[i].sh_type == SHT_RELA)
1924             section_rela(modname, elf, &elf->sechdrs[i]);
1925         else if (sechdrs[i].sh_type == SHT_REL)
1926             section_rel(modname, elf, &elf->sechdrs[i]);
1927     }
1928 }
1929 
1930 static char *remove_dot(char *s)
1931 {
1932     size_t n = strcspn(s, ".");
1933 
1934     if (n && s[n]) {
1935         size_t m = strspn(s + n + 1, "0123456789");
1936         if (m && (s[n + m] == '.' || s[n + m] == 0))
1937             s[n] = 0;
1938     }
1939     return s;
1940 }
1941 
1942 static void read_symbols(char *modname)
1943 {
1944     const char *symname;
1945     char *version;
1946     char *license;
1947     struct module *mod;
1948     struct elf_info info = { };
1949     Elf_Sym *sym;
1950 
1951     if (!parse_elf(&info, modname))
1952         return;
1953 
1954     mod = new_module(modname);
1955 
1956     /* When there's no vmlinux, don't print warnings about
1957      * unresolved symbols (since there'll be too many ;) */
1958     if (is_vmlinux(modname)) {
1959         have_vmlinux = 1;
1960         mod->skip = 1;
1961     }
1962 
1963     license = get_modinfo(info.modinfo, info.modinfo_len, "license");
1964     if (info.modinfo && !license && !is_vmlinux(modname))
1965         warn("modpost: missing MODULE_LICENSE() in %s\n"
1966              "see include/linux/module.h for "
1967              "more information\n", modname);
1968     while (license) {
1969         if (license_is_gpl_compatible(license))
1970             mod->gpl_compatible = 1;
1971         else {
1972             mod->gpl_compatible = 0;
1973             break;
1974         }
1975         license = get_next_modinfo(info.modinfo, info.modinfo_len,
1976                        "license", license);
1977     }
1978 
1979     for (sym = info.symtab_start; sym < info.symtab_stop; sym++) {
1980         symname = remove_dot(info.strtab + sym->st_name);
1981 
1982         handle_modversions(mod, &info, sym, symname);
1983         handle_moddevtable(mod, &info, sym, symname);
1984     }
1985     if (!is_vmlinux(modname) ||
1986          (is_vmlinux(modname) && vmlinux_section_warnings))
1987         check_sec_ref(mod, modname, &info);
1988 
1989     version = get_modinfo(info.modinfo, info.modinfo_len, "version");
1990     if (version)
1991         maybe_frob_rcs_version(modname, version, info.modinfo,
1992                        version - (char *)info.hdr);
1993     if (version || (all_versions && !is_vmlinux(modname)))
1994         get_src_version(modname, mod->srcversion,
1995                 sizeof(mod->srcversion)-1);
1996 
1997     parse_elf_finish(&info);
1998 
1999     /* Our trick to get versioning for module struct etc. - it's
2000      * never passed as an argument to an exported function, so
2001      * the automatic versioning doesn't pick it up, but it's really
2002      * important anyhow */
2003     if (modversions)
2004         mod->unres = alloc_symbol("module_layout", 0, mod->unres);
2005 }
2006 
2007 static void read_symbols_from_files(const char *filename)
2008 {
2009     FILE *in = stdin;
2010     char fname[PATH_MAX];
2011 
2012     if (strcmp(filename, "-") != 0) {
2013         in = fopen(filename, "r");
2014         if (!in)
2015             fatal("Can't open filenames file %s: %m", filename);
2016     }
2017 
2018     while (fgets(fname, PATH_MAX, in) != NULL) {
2019         if (strends(fname, "\n"))
2020             fname[strlen(fname)-1] = '\0';
2021         read_symbols(fname);
2022     }
2023 
2024     if (in != stdin)
2025         fclose(in);
2026 }
2027 
2028 #define SZ 500
2029 
2030 /* We first write the generated file into memory using the
2031  * following helper, then compare to the file on disk and
2032  * only update the later if anything changed */
2033 
2034 void __attribute__((format(printf, 2, 3))) buf_printf(struct buffer *buf,
2035                               const char *fmt, ...)
2036 {
2037     char tmp[SZ];
2038     int len;
2039     va_list ap;
2040 
2041     va_start(ap, fmt);
2042     len = vsnprintf(tmp, SZ, fmt, ap);
2043     buf_write(buf, tmp, len);
2044     va_end(ap);
2045 }
2046 
2047 void buf_write(struct buffer *buf, const char *s, int len)
2048 {
2049     if (buf->size - buf->pos < len) {
2050         buf->size += len + SZ;
2051         buf->p = realloc(buf->p, buf->size);
2052     }
2053     strncpy(buf->p + buf->pos, s, len);
2054     buf->pos += len;
2055 }
2056 
2057 static void check_for_gpl_usage(enum export exp, const char *m, const char *s)
2058 {
2059     const char *e = is_vmlinux(m) ?"":".ko";
2060 
2061     switch (exp) {
2062     case export_gpl:
2063         fatal("modpost: GPL-incompatible module %s%s "
2064               "uses GPL-only symbol '%s'\n", m, e, s);
2065         break;
2066     case export_unused_gpl:
2067         fatal("modpost: GPL-incompatible module %s%s "
2068               "uses GPL-only symbol marked UNUSED '%s'\n", m, e, s);
2069         break;
2070     case export_gpl_future:
2071         warn("modpost: GPL-incompatible module %s%s "
2072               "uses future GPL-only symbol '%s'\n", m, e, s);
2073         break;
2074     case export_plain:
2075     case export_unused:
2076     case export_unknown:
2077         /* ignore */
2078         break;
2079     }
2080 }
2081 
2082 static void check_for_unused(enum export exp, const char *m, const char *s)
2083 {
2084     const char *e = is_vmlinux(m) ?"":".ko";
2085 
2086     switch (exp) {
2087     case export_unused:
2088     case export_unused_gpl:
2089         warn("modpost: module %s%s "
2090               "uses symbol '%s' marked UNUSED\n", m, e, s);
2091         break;
2092     default:
2093         /* ignore */
2094         break;
2095     }
2096 }
2097 
2098 static void check_exports(struct module *mod)
2099 {
2100     struct symbol *s, *exp;
2101 
2102     for (s = mod->unres; s; s = s->next) {
2103         const char *basename;
2104         exp = find_symbol(s->name);
2105         if (!exp || exp->module == mod)
2106             continue;
2107         basename = strrchr(mod->name, '/');
2108         if (basename)
2109             basename++;
2110         else
2111             basename = mod->name;
2112         if (!mod->gpl_compatible)
2113             check_for_gpl_usage(exp->export, basename, exp->name);
2114         check_for_unused(exp->export, basename, exp->name);
2115     }
2116 }
2117 
2118 /**
2119  * Header for the generated file
2120  **/
2121 static void add_header(struct buffer *b, struct module *mod)
2122 {
2123     buf_printf(b, "#include <linux/module.h>\n");
2124     buf_printf(b, "#include <linux/vermagic.h>\n");
2125     buf_printf(b, "#include <linux/compiler.h>\n");
2126     buf_printf(b, "\n");
2127     buf_printf(b, "MODULE_INFO(vermagic, VERMAGIC_STRING);\n");
2128     buf_printf(b, "\n");
2129     buf_printf(b, "__visible struct module __this_module\n");
2130     buf_printf(b, "__attribute__((section(\".gnu.linkonce.this_module\"))) = {\n");
2131     buf_printf(b, "\t.name = KBUILD_MODNAME,\n");
2132     if (mod->has_init)
2133         buf_printf(b, "\t.init = init_module,\n");
2134     if (mod->has_cleanup)
2135         buf_printf(b, "#ifdef CONFIG_MODULE_UNLOAD\n"
2136                   "\t.exit = cleanup_module,\n"
2137                   "#endif\n");
2138     buf_printf(b, "\t.arch = MODULE_ARCH_INIT,\n");
2139     buf_printf(b, "};\n");
2140 }
2141 
2142 static void add_intree_flag(struct buffer *b, int is_intree)
2143 {
2144     if (is_intree)
2145         buf_printf(b, "\nMODULE_INFO(intree, \"Y\");\n");
2146 }
2147 
2148 static void add_staging_flag(struct buffer *b, const char *name)
2149 {
2150     static const char *staging_dir = "drivers/staging";
2151 
2152     if (strncmp(staging_dir, name, strlen(staging_dir)) == 0)
2153         buf_printf(b, "\nMODULE_INFO(staging, \"Y\");\n");
2154 }
2155 
2156 /* In kernel, this size is defined in linux/module.h;
2157  * here we use Elf_Addr instead of long for covering cross-compile
2158  */
2159 #define MODULE_NAME_LEN (64 - sizeof(Elf_Addr))
2160 
2161 /**
2162  * Record CRCs for unresolved symbols
2163  **/
2164 static int add_versions(struct buffer *b, struct module *mod)
2165 {
2166     struct symbol *s, *exp;
2167     int err = 0;
2168 
2169     for (s = mod->unres; s; s = s->next) {
2170         exp = find_symbol(s->name);
2171         if (!exp || exp->module == mod) {
2172             if (have_vmlinux && !s->weak) {
2173                 if (warn_unresolved) {
2174                     warn("\"%s\" [%s.ko] undefined!\n",
2175                          s->name, mod->name);
2176                 } else {
2177                     merror("\"%s\" [%s.ko] undefined!\n",
2178                            s->name, mod->name);
2179                     err = 1;
2180                 }
2181             }
2182             continue;
2183         }
2184         s->module = exp->module;
2185         s->crc_valid = exp->crc_valid;
2186         s->crc = exp->crc;
2187     }
2188 
2189     if (!modversions)
2190         return err;
2191 
2192     buf_printf(b, "\n");
2193     buf_printf(b, "static const struct modversion_info ____versions[]\n");
2194     buf_printf(b, "__used\n");
2195     buf_printf(b, "__attribute__((section(\"__versions\"))) = {\n");
2196 
2197     for (s = mod->unres; s; s = s->next) {
2198         if (!s->module)
2199             continue;
2200         if (!s->crc_valid) {
2201             warn("\"%s\" [%s.ko] has no CRC!\n",
2202                 s->name, mod->name);
2203             continue;
2204         }
2205         if (strlen(s->name) >= MODULE_NAME_LEN) {
2206             merror("too long symbol \"%s\" [%s.ko]\n",
2207                    s->name, mod->name);
2208             err = 1;
2209             break;
2210         }
2211         buf_printf(b, "\t{ %#8x, __VMLINUX_SYMBOL_STR(%s) },\n",
2212                s->crc, s->name);
2213     }
2214 
2215     buf_printf(b, "};\n");
2216 
2217     return err;
2218 }
2219 
2220 static void add_depends(struct buffer *b, struct module *mod,
2221             struct module *modules)
2222 {
2223     struct symbol *s;
2224     struct module *m;
2225     int first = 1;
2226 
2227     for (m = modules; m; m = m->next)
2228         m->seen = is_vmlinux(m->name);
2229 
2230     buf_printf(b, "\n");
2231     buf_printf(b, "static const char __module_depends[]\n");
2232     buf_printf(b, "__used\n");
2233     buf_printf(b, "__attribute__((section(\".modinfo\"))) =\n");
2234     buf_printf(b, "\"depends=");
2235     for (s = mod->unres; s; s = s->next) {
2236         const char *p;
2237         if (!s->module)
2238             continue;
2239 
2240         if (s->module->seen)
2241             continue;
2242 
2243         s->module->seen = 1;
2244         p = strrchr(s->module->name, '/');
2245         if (p)
2246             p++;
2247         else
2248             p = s->module->name;
2249         buf_printf(b, "%s%s", first ? "" : ",", p);
2250         first = 0;
2251     }
2252     buf_printf(b, "\";\n");
2253 }
2254 
2255 static void add_srcversion(struct buffer *b, struct module *mod)
2256 {
2257     if (mod->srcversion[0]) {
2258         buf_printf(b, "\n");
2259         buf_printf(b, "MODULE_INFO(srcversion, \"%s\");\n",
2260                mod->srcversion);
2261     }
2262 }
2263 
2264 static void write_if_changed(struct buffer *b, const char *fname)
2265 {
2266     char *tmp;
2267     FILE *file;
2268     struct stat st;
2269 
2270     file = fopen(fname, "r");
2271     if (!file)
2272         goto write;
2273 
2274     if (fstat(fileno(file), &st) < 0)
2275         goto close_write;
2276 
2277     if (st.st_size != b->pos)
2278         goto close_write;
2279 
2280     tmp = NOFAIL(malloc(b->pos));
2281     if (fread(tmp, 1, b->pos, file) != b->pos)
2282         goto free_write;
2283 
2284     if (memcmp(tmp, b->p, b->pos) != 0)
2285         goto free_write;
2286 
2287     free(tmp);
2288     fclose(file);
2289     return;
2290 
2291  free_write:
2292     free(tmp);
2293  close_write:
2294     fclose(file);
2295  write:
2296     file = fopen(fname, "w");
2297     if (!file) {
2298         perror(fname);
2299         exit(1);
2300     }
2301     if (fwrite(b->p, 1, b->pos, file) != b->pos) {
2302         perror(fname);
2303         exit(1);
2304     }
2305     fclose(file);
2306 }
2307 
2308 /* parse Module.symvers file. line format:
2309  * 0x12345678<tab>symbol<tab>module[[<tab>export]<tab>something]
2310  **/
2311 static void read_dump(const char *fname, unsigned int kernel)
2312 {
2313     unsigned long size, pos = 0;
2314     void *file = grab_file(fname, &size);
2315     char *line;
2316 
2317     if (!file)
2318         /* No symbol versions, silently ignore */
2319         return;
2320 
2321     while ((line = get_next_line(&pos, file, size))) {
2322         char *symname, *modname, *d, *export, *end;
2323         unsigned int crc;
2324         struct module *mod;
2325         struct symbol *s;
2326 
2327         if (!(symname = strchr(line, '\t')))
2328             goto fail;
2329         *symname++ = '\0';
2330         if (!(modname = strchr(symname, '\t')))
2331             goto fail;
2332         *modname++ = '\0';
2333         if ((export = strchr(modname, '\t')) != NULL)
2334             *export++ = '\0';
2335         if (export && ((end = strchr(export, '\t')) != NULL))
2336             *end = '\0';
2337         crc = strtoul(line, &d, 16);
2338         if (*symname == '\0' || *modname == '\0' || *d != '\0')
2339             goto fail;
2340         mod = find_module(modname);
2341         if (!mod) {
2342             if (is_vmlinux(modname))
2343                 have_vmlinux = 1;
2344             mod = new_module(modname);
2345             mod->skip = 1;
2346         }
2347         s = sym_add_exported(symname, mod, export_no(export));
2348         s->kernel    = kernel;
2349         s->preloaded = 1;
2350         sym_update_crc(symname, mod, crc, export_no(export));
2351     }
2352     release_file(file, size);
2353     return;
2354 fail:
2355     release_file(file, size);
2356     fatal("parse error in symbol dump file\n");
2357 }
2358 
2359 /* For normal builds always dump all symbols.
2360  * For external modules only dump symbols
2361  * that are not read from kernel Module.symvers.
2362  **/
2363 static int dump_sym(struct symbol *sym)
2364 {
2365     if (!external_module)
2366         return 1;
2367     if (sym->vmlinux || sym->kernel)
2368         return 0;
2369     return 1;
2370 }
2371 
2372 static void write_dump(const char *fname)
2373 {
2374     struct buffer buf = { };
2375     struct symbol *symbol;
2376     int n;
2377 
2378     for (n = 0; n < SYMBOL_HASH_SIZE ; n++) {
2379         symbol = symbolhash[n];
2380         while (symbol) {
2381             if (dump_sym(symbol))
2382                 buf_printf(&buf, "0x%08x\t%s\t%s\t%s\n",
2383                     symbol->crc, symbol->name,
2384                     symbol->module->name,
2385                     export_str(symbol->export));
2386             symbol = symbol->next;
2387         }
2388     }
2389     write_if_changed(&buf, fname);
2390     free(buf.p);
2391 }
2392 
2393 struct ext_sym_list {
2394     struct ext_sym_list *next;
2395     const char *file;
2396 };
2397 
2398 int main(int argc, char **argv)
2399 {
2400     struct module *mod;
2401     struct buffer buf = { };
2402     char *kernel_read = NULL, *module_read = NULL;
2403     char *dump_write = NULL, *files_source = NULL;
2404     int opt;
2405     int err;
2406     struct ext_sym_list *extsym_iter;
2407     struct ext_sym_list *extsym_start = NULL;
2408 
2409     while ((opt = getopt(argc, argv, "i:I:e:mnsST:o:awM:K:E")) != -1) {
2410         switch (opt) {
2411         case 'i':
2412             kernel_read = optarg;
2413             break;
2414         case 'I':
2415             module_read = optarg;
2416             external_module = 1;
2417             break;
2418         case 'e':
2419             external_module = 1;
2420             extsym_iter =
2421                NOFAIL(malloc(sizeof(*extsym_iter)));
2422             extsym_iter->next = extsym_start;
2423             extsym_iter->file = optarg;
2424             extsym_start = extsym_iter;
2425             break;
2426         case 'm':
2427             modversions = 1;
2428             break;
2429         case 'n':
2430             ignore_missing_files = 1;
2431             break;
2432         case 'o':
2433             dump_write = optarg;
2434             break;
2435         case 'a':
2436             all_versions = 1;
2437             break;
2438         case 's':
2439             vmlinux_section_warnings = 0;
2440             break;
2441         case 'S':
2442             sec_mismatch_verbose = 0;
2443             break;
2444         case 'T':
2445             files_source = optarg;
2446             break;
2447         case 'w':
2448             warn_unresolved = 1;
2449             break;
2450         case 'E':
2451             sec_mismatch_fatal = 1;
2452             break;
2453         default:
2454             exit(1);
2455         }
2456     }
2457 
2458     if (kernel_read)
2459         read_dump(kernel_read, 1);
2460     if (module_read)
2461         read_dump(module_read, 0);
2462     while (extsym_start) {
2463         read_dump(extsym_start->file, 0);
2464         extsym_iter = extsym_start->next;
2465         free(extsym_start);
2466         extsym_start = extsym_iter;
2467     }
2468 
2469     while (optind < argc)
2470         read_symbols(argv[optind++]);
2471 
2472     if (files_source)
2473         read_symbols_from_files(files_source);
2474 
2475     for (mod = modules; mod; mod = mod->next) {
2476         if (mod->skip)
2477             continue;
2478         check_exports(mod);
2479     }
2480 
2481     err = 0;
2482 
2483     for (mod = modules; mod; mod = mod->next) {
2484         char fname[PATH_MAX];
2485 
2486         if (mod->skip)
2487             continue;
2488 
2489         buf.pos = 0;
2490 
2491         add_header(&buf, mod);
2492         add_intree_flag(&buf, !external_module);
2493         add_staging_flag(&buf, mod->name);
2494         err |= add_versions(&buf, mod);
2495         add_depends(&buf, mod, modules);
2496         add_moddevtable(&buf, mod);
2497         add_srcversion(&buf, mod);
2498 
2499         sprintf(fname, "%s.mod.c", mod->name);
2500         write_if_changed(&buf, fname);
2501     }
2502     if (dump_write)
2503         write_dump(dump_write);
2504     if (sec_mismatch_count) {
2505         if (!sec_mismatch_verbose) {
2506             warn("modpost: Found %d section mismatch(es).\n"
2507                  "To see full details build your kernel with:\n"
2508                  "'make CONFIG_DEBUG_SECTION_MISMATCH=y'\n",
2509                  sec_mismatch_count);
2510         }
2511         if (sec_mismatch_fatal) {
2512             fatal("modpost: Section mismatches detected.\n"
2513                   "Set CONFIG_SECTION_MISMATCH_WARN_ONLY=y to allow them.\n");
2514         }
2515     }
2516     free(buf.p);
2517 
2518     return err;
2519 }