/* Postprocess module symbol versions * * Copyright 2003 Kai Germaschewski * Copyright 2002-2004 Rusty Russell, IBM Corporation * Copyright 2006-2008 Sam Ravnborg * Based in part on module-init-tools/depmod.c,file2alias * * This software may be used and distributed according to the terms * of the GNU General Public License, incorporated herein by reference. * * Usage: modpost vmlinux module1.o module2.o ... */ #define _GNU_SOURCE#include <elf.h>#include <stdio.h>#include <ctype.h>#include <string.h>#include <limits.h>#include <stdbool.h>#include <errno.h>#include "modpost.h"#include "../../include/linux/license.h" /* Are we using CONFIG_MODVERSIONS? */static int modversions = 0;/* Warn about undefined symbols? (do so if we have vmlinux) */static int have_vmlinux = 0;/* Is CONFIG_MODULE_SRCVERSION_ALL set? */static int all_versions = 0;/* If we are modposting external module set to 1 */static int external_module = 0;/* Only warn about unresolved symbols */static int warn_unresolved = 0;/* How a symbol is exported */static int sec_mismatch_count = 0;static int sec_mismatch_fatal = 0;/* ignore missing files */static int ignore_missing_files;/* If set to 1, only warn (instead of error) about missing ns imports */static int allow_missing_ns_imports; enum export { export_plain, export_unused, export_gpl, export_unused_gpl, export_gpl_future, export_unknown}; /* In kernel, this size is defined in linux/module.h; * here we use Elf_Addr instead of long for covering cross-compile */ #define MODULE_NAME_LEN (64 - sizeof(Elf_Addr)) void __attribute__((format(printf, 2, 3)))modpost_log(enum loglevel loglevel, const char *fmt, ...){ va_list arglist; switch (loglevel) { case LOG_WARN: fprintf(stderr, "WARNING: "); break; case LOG_ERROR: fprintf(stderr, "ERROR: "); break; case LOG_FATAL: fprintf(stderr, "FATAL: "); break; default: /* invalid loglevel, ignore */ break; } fprintf(stderr, "modpost: "); va_start(arglist, fmt); vfprintf(stderr, fmt, arglist); va_end(arglist); if (loglevel == LOG_FATAL) exit(1);} static inline bool strends(const char *str, const char *postfix){ if (strlen(str) < strlen(postfix)) return false; return strcmp(str + strlen(str) - strlen(postfix), postfix) == 0;} void *do_nofail(void *ptr, const char *expr){ if (!ptr) fatal("Memory allocation failure: %s.\n", expr); return ptr;} char *read_text_file(const char *filename){ struct stat st; size_t nbytes; int fd; char *buf; fd = open(filename, O_RDONLY); if (fd < 0) { perror(filename); exit(1); } if (fstat(fd, &st) < 0) { perror(filename); exit(1); } buf = NOFAIL(malloc(st.st_size + 1)); nbytes = st.st_size; while (nbytes) { ssize_t bytes_read; bytes_read = read(fd, buf, nbytes); if (bytes_read < 0) { perror(filename); exit(1); } nbytes -= bytes_read; } buf[st.st_size] = '\0'; close(fd); return buf;} char *get_line(char **stringp){ /* do not return the unwanted extra line at EOF */ if (*stringp && **stringp == '\0') return NULL; return strsep(stringp, "\n");} /* A list of all modules we processed */static struct module *modules; static struct module *find_module(const char *modname){ struct module *mod; for (mod = modules; mod; mod = mod->next) if (strcmp(mod->name, modname) == 0) break; return mod;} static struct module *new_module(const char *modname){ struct module *mod; mod = NOFAIL(malloc(sizeof(*mod) + strlen(modname) + 1)); memset(mod, 0, sizeof(*mod)); /* add to list */ strcpy(mod->name, modname); mod->is_vmlinux = (strcmp(modname, "vmlinux") == 0); mod->gpl_compatible = -1; mod->next = modules; modules = mod; if (mod->is_vmlinux) have_vmlinux = 1; return mod;} /* A hash of all exported symbols, * struct symbol is also used for lists of unresolved symbols */ #define SYMBOL_HASH_SIZE 1024 struct symbol { struct symbol *next; struct module *module; unsigned int crc; int crc_valid; char *namespace; unsigned int weak:1; unsigned int is_static:1; /* 1 if symbol is not global */ enum export export; /* Type of export */ char name[];}; static struct symbol *symbolhash[SYMBOL_HASH_SIZE]; /* This is based on the hash agorithm from gdbm, via tdb */static inline unsigned int tdb_hash(const char *name){ unsigned value; /* Used to compute the hash value. */ unsigned i; /* Used to cycle through random values. */ /* Set the initial value from the key size. */ for (value = 0x238F13AF * strlen(name), i = 0; name[i]; i++) value = (value + (((unsigned char *)name)[i] << (i*5 % 24))); return (1103515243 * value + 12345);} /** * Allocate a new symbols for use in the hash of exported symbols or * the list of unresolved symbols per module **/static struct symbol *alloc_symbol(const char *name, unsigned int weak, struct symbol *next){ struct symbol *s = NOFAIL(malloc(sizeof(*s) + strlen(name) + 1)); memset(s, 0, sizeof(*s)); strcpy(s->name, name); s->weak = weak; s->next = next; s->is_static = 1; return s;} /* For the hash of exported symbols */static struct symbol *new_symbol(const char *name, struct module *module, enum export export){ unsigned int hash; hash = tdb_hash(name) % SYMBOL_HASH_SIZE; symbolhash[hash] = alloc_symbol(name, 0, symbolhash[hash]); return symbolhash[hash];} static struct symbol *find_symbol(const char *name){ struct symbol *s; /* For our purposes, .foo matches foo. PPC64 needs this. */ if (name[0] == '.') name++; for (s = symbolhash[tdb_hash(name) % SYMBOL_HASH_SIZE]; s; s = s->next) { if (strcmp(s->name, name) == 0) return s; } return NULL;} static bool contains_namespace(struct namespace_list *list, const char *namespace){ for (; list; list = list->next) if (!strcmp(list->namespace, namespace)) return true; return false;} static void add_namespace(struct namespace_list **list, const char *namespace){ struct namespace_list *ns_entry; if (!contains_namespace(*list, namespace)) { ns_entry = NOFAIL(malloc(sizeof(struct namespace_list) + strlen(namespace) + 1)); strcpy(ns_entry->namespace, namespace); ns_entry->next = *list; *list = ns_entry; }} static bool module_imports_namespace(struct module *module, const char *namespace){ return contains_namespace(module->imported_namespaces, namespace);} static const struct { const char *str; enum export export;} export_list[] = { { .str = "EXPORT_SYMBOL", .export = export_plain }, { .str = "EXPORT_UNUSED_SYMBOL", .export = export_unused }, { .str = "EXPORT_SYMBOL_GPL", .export = export_gpl }, { .str = "EXPORT_UNUSED_SYMBOL_GPL", .export = export_unused_gpl }, { .str = "EXPORT_SYMBOL_GPL_FUTURE", .export = export_gpl_future }, { .str = "(unknown)", .export = export_unknown },}; static const char *export_str(enum export ex){ return export_list[ex].str;} static enum export export_no(const char *s){ int i; if (!s) return export_unknown; for (i = 0; export_list[i].export != export_unknown; i++) { if (strcmp(export_list[i].str, s) == 0) return export_list[i].export; } return export_unknown;} static void *sym_get_data_by_offset(const struct elf_info *info, unsigned int secindex, unsigned long offset){ Elf_Shdr *sechdr = &info->sechdrs[secindex]; if (info->hdr->e_type != ET_REL) offset -= sechdr->sh_addr; return (void *)info->hdr + sechdr->sh_offset + offset;} static void *sym_get_data(const struct elf_info *info, const Elf_Sym *sym){ return sym_get_data_by_offset(info, get_secindex(info, sym), sym->st_value);} static const char *sech_name(const struct elf_info *info, Elf_Shdr *sechdr){ return sym_get_data_by_offset(info, info->secindex_strings, sechdr->sh_name);} static const char *sec_name(const struct elf_info *info, int secindex){ return sech_name(info, &info->sechdrs[secindex]);} #define strstarts(str, prefix) (strncmp(str, prefix, strlen(prefix)) == 0) static enum export export_from_secname(struct elf_info *elf, unsigned int sec){ const char *secname = sec_name(elf, sec); if (strstarts(secname, "___ksymtab+")) return export_plain; else if (strstarts(secname, "___ksymtab_unused+")) return export_unused; else if (strstarts(secname, "___ksymtab_gpl+")) return export_gpl; else if (strstarts(secname, "___ksymtab_unused_gpl+")) return export_unused_gpl; else if (strstarts(secname, "___ksymtab_gpl_future+")) return export_gpl_future; else return export_unknown;} static enum export export_from_sec(struct elf_info *elf, unsigned int sec){ if (sec == elf->export_sec) return export_plain; else if (sec == elf->export_unused_sec) return export_unused; else if (sec == elf->export_gpl_sec) return export_gpl; else if (sec == elf->export_unused_gpl_sec) return export_unused_gpl; else if (sec == elf->export_gpl_future_sec) return export_gpl_future; else return export_unknown;} static const char *namespace_from_kstrtabns(const struct elf_info *info, const Elf_Sym *sym){ const char *value = sym_get_data(info, sym); return value[0] ? value : NULL;} static void sym_update_namespace(const char *symname, const char *namespace){ struct symbol *s = find_symbol(symname); /* * That symbol should have been created earlier and thus this is * actually an assertion. */ if (!s) { merror("Could not update namespace(%s) for symbol %s\n", namespace, symname); return; } free(s->namespace); s->namespace = namespace && namespace[0] ? NOFAIL(strdup(namespace)) : NULL;} /** * Add an exported symbol - it may have already been added without a * CRC, in this case just update the CRC **/static struct symbol *sym_add_exported(const char *name, struct module *mod, enum export export){ struct symbol *s = find_symbol(name); if (!s) { s = new_symbol(name, mod, export); } else if (!external_module || s->module->is_vmlinux || s->module == mod) { warn("%s: '%s' exported twice. Previous export was in %s%s\n", mod->name, name, s->module->name, s->module->is_vmlinux ? "" : ".ko"); return s; } s->module = mod; s->export = export; return s;} static void sym_set_crc(const char *name, unsigned int crc){ struct symbol *s = find_symbol(name); /* * Ignore stand-alone __crc_*, which might be auto-generated symbols * such as __*_veneer in ARM ELF. */ if (!s) return; s->crc = crc; s->crc_valid = 1;} static void *grab_file(const char *filename, size_t *size){ struct stat st; void *map = MAP_FAILED; int fd; fd = open(filename, O_RDONLY); if (fd < 0) return NULL; if (fstat(fd, &st)) goto failed; *size = st.st_size; map = mmap(NULL, *size, PROT_READ|PROT_WRITE, MAP_PRIVATE, fd, 0); failed: close(fd); if (map == MAP_FAILED) return NULL; return map;} static void release_file(void *file, size_t size){ munmap(file, size);} static int parse_elf(struct elf_info *info, const char *filename){ unsigned int i; Elf_Ehdr *hdr; Elf_Shdr *sechdrs; Elf_Sym *sym; const char *secstrings; unsigned int symtab_idx = ~0U, symtab_shndx_idx = ~0U; hdr = grab_file(filename, &info->size); if (!hdr) { if (ignore_missing_files) { fprintf(stderr, "%s: %s (ignored)\n", filename, strerror(errno)); return 0; } perror(filename); exit(1); } info->hdr = hdr; if (info->size < sizeof(*hdr)) { /* file too small, assume this is an empty .o file */ return 0; } /* Is this a valid ELF file? */ if ((hdr->e_ident[EI_MAG0] != ELFMAG0) || (hdr->e_ident[EI_MAG1] != ELFMAG1) || (hdr->e_ident[EI_MAG2] != ELFMAG2) ||Lines 1–500 of 2666. Load more
/* Postprocess module symbol versions * * Copyright 2003 Kai Germaschewski * Copyright 2002-2004 Rusty Russell, IBM Corporation * Copyright 2006-2008 Sam Ravnborg * Based in part on module-init-tools/depmod.c,file2alias * * This software may be used and distributed according to the terms * of the GNU General Public License, incorporated herein by reference. * * Usage: modpost vmlinux module1.o module2.o ... */ #define _GNU_SOURCE #include <elf.h> #include <stdio.h> #include <ctype.h> #include <string.h> #include <limits.h> #include <stdbool.h> #include <errno.h> #include "modpost.h" #include "../../include/linux/license.h" /* Are we using CONFIG_MODVERSIONS? */ static int modversions = 0; /* Warn about undefined symbols? (do so if we have vmlinux) */ static int have_vmlinux = 0; /* Is CONFIG_MODULE_SRCVERSION_ALL set? */ static int all_versions = 0; /* If we are modposting external module set to 1 */ static int external_module = 0; /* Only warn about unresolved symbols */ static int warn_unresolved = 0; /* How a symbol is exported */ static int sec_mismatch_count = 0; static int sec_mismatch_fatal = 0; /* ignore missing files */ static int ignore_missing_files; /* If set to 1, only warn (instead of error) about missing ns imports */ static int allow_missing_ns_imports; enum export { export_plain, export_unused, export_gpl, export_unused_gpl, export_gpl_future, export_unknown }; /* In kernel, this size is defined in linux/module.h; * here we use Elf_Addr instead of long for covering cross-compile */ #define MODULE_NAME_LEN (64 - sizeof(Elf_Addr)) void __attribute__((format(printf, 2, 3))) modpost_log(enum loglevel loglevel, const char *fmt, ...) { va_list arglist; switch (loglevel) { case LOG_WARN: fprintf(stderr, "WARNING: "); break; case LOG_ERROR: fprintf(stderr, "ERROR: "); break; case LOG_FATAL: fprintf(stderr, "FATAL: "); break; default: /* invalid loglevel, ignore */ break; } fprintf(stderr, "modpost: "); va_start(arglist, fmt); vfprintf(stderr, fmt, arglist); va_end(arglist); if (loglevel == LOG_FATAL) exit(1); } static inline bool strends(const char *str, const char *postfix) { if (strlen(str) < strlen(postfix)) return false; return strcmp(str + strlen(str) - strlen(postfix), postfix) == 0; } void *do_nofail(void *ptr, const char *expr) { if (!ptr) fatal("Memory allocation failure: %s.\n", expr); return ptr; } char *read_text_file(const char *filename) { struct stat st; size_t nbytes; int fd; char *buf; fd = open(filename, O_RDONLY); if (fd < 0) { perror(filename); exit(1); } if (fstat(fd, &st) < 0) { perror(filename); exit(1); } buf = NOFAIL(malloc(st.st_size + 1)); nbytes = st.st_size; while (nbytes) { ssize_t bytes_read; bytes_read = read(fd, buf, nbytes); if (bytes_read < 0) { perror(filename); exit(1); } nbytes -= bytes_read; } buf[st.st_size] = '\0'; close(fd); return buf; } char *get_line(char **stringp) { /* do not return the unwanted extra line at EOF */ if (*stringp && **stringp == '\0') return NULL; return strsep(stringp, "\n"); } /* A list of all modules we processed */ static struct module *modules; static struct module *find_module(const char *modname) { struct module *mod; for (mod = modules; mod; mod = mod->next) if (strcmp(mod->name, modname) == 0) break; return mod; } static struct module *new_module(const char *modname) { struct module *mod; mod = NOFAIL(malloc(sizeof(*mod) + strlen(modname) + 1)); memset(mod, 0, sizeof(*mod)); /* add to list */ strcpy(mod->name, modname); mod->is_vmlinux = (strcmp(modname, "vmlinux") == 0); mod->gpl_compatible = -1; mod->next = modules; modules = mod; if (mod->is_vmlinux) have_vmlinux = 1; return mod; } /* A hash of all exported symbols, * struct symbol is also used for lists of unresolved symbols */ #define SYMBOL_HASH_SIZE 1024 struct symbol { struct symbol *next; struct module *module; unsigned int crc; int crc_valid; char *namespace; unsigned int weak:1; unsigned int is_static:1; /* 1 if symbol is not global */ enum export export; /* Type of export */ char name[]; }; static struct symbol *symbolhash[SYMBOL_HASH_SIZE]; /* This is based on the hash agorithm from gdbm, via tdb */ static inline unsigned int tdb_hash(const char *name) { unsigned value; /* Used to compute the hash value. */ unsigned i; /* Used to cycle through random values. */ /* Set the initial value from the key size. */ for (value = 0x238F13AF * strlen(name), i = 0; name[i]; i++) value = (value + (((unsigned char *)name)[i] << (i*5 % 24))); return (1103515243 * value + 12345); } /** * Allocate a new symbols for use in the hash of exported symbols or * the list of unresolved symbols per module **/ static struct symbol *alloc_symbol(const char *name, unsigned int weak, struct symbol *next) { struct symbol *s = NOFAIL(malloc(sizeof(*s) + strlen(name) + 1)); memset(s, 0, sizeof(*s)); strcpy(s->name, name); s->weak = weak; s->next = next; s->is_static = 1; return s; } /* For the hash of exported symbols */ static struct symbol *new_symbol(const char *name, struct module *module, enum export export) { unsigned int hash; hash = tdb_hash(name) % SYMBOL_HASH_SIZE; symbolhash[hash] = alloc_symbol(name, 0, symbolhash[hash]); return symbolhash[hash]; } static struct symbol *find_symbol(const char *name) { struct symbol *s; /* For our purposes, .foo matches foo. PPC64 needs this. */ if (name[0] == '.') name++; for (s = symbolhash[tdb_hash(name) % SYMBOL_HASH_SIZE]; s; s = s->next) { if (strcmp(s->name, name) == 0) return s; } return NULL; } static bool contains_namespace(struct namespace_list *list, const char *namespace) { for (; list; list = list->next) if (!strcmp(list->namespace, namespace)) return true; return false; } static void add_namespace(struct namespace_list **list, const char *namespace) { struct namespace_list *ns_entry; if (!contains_namespace(*list, namespace)) { ns_entry = NOFAIL(malloc(sizeof(struct namespace_list) + strlen(namespace) + 1)); strcpy(ns_entry->namespace, namespace); ns_entry->next = *list; *list = ns_entry; } } static bool module_imports_namespace(struct module *module, const char *namespace) { return contains_namespace(module->imported_namespaces, namespace); } static const struct { const char *str; enum export export; } export_list[] = { { .str = "EXPORT_SYMBOL", .export = export_plain }, { .str = "EXPORT_UNUSED_SYMBOL", .export = export_unused }, { .str = "EXPORT_SYMBOL_GPL", .export = export_gpl }, { .str = "EXPORT_UNUSED_SYMBOL_GPL", .export = export_unused_gpl }, { .str = "EXPORT_SYMBOL_GPL_FUTURE", .export = export_gpl_future }, { .str = "(unknown)", .export = export_unknown }, }; static const char *export_str(enum export ex) { return export_list[ex].str; } static enum export export_no(const char *s) { int i; if (!s) return export_unknown; for (i = 0; export_list[i].export != export_unknown; i++) { if (strcmp(export_list[i].str, s) == 0) return export_list[i].export; } return export_unknown; } static void *sym_get_data_by_offset(const struct elf_info *info, unsigned int secindex, unsigned long offset) { Elf_Shdr *sechdr = &info->sechdrs[secindex]; if (info->hdr->e_type != ET_REL) offset -= sechdr->sh_addr; return (void *)info->hdr + sechdr->sh_offset + offset; } static void *sym_get_data(const struct elf_info *info, const Elf_Sym *sym) { return sym_get_data_by_offset(info, get_secindex(info, sym), sym->st_value); } static const char *sech_name(const struct elf_info *info, Elf_Shdr *sechdr) { return sym_get_data_by_offset(info, info->secindex_strings, sechdr->sh_name); } static const char *sec_name(const struct elf_info *info, int secindex) { return sech_name(info, &info->sechdrs[secindex]); } #define strstarts(str, prefix) (strncmp(str, prefix, strlen(prefix)) == 0) static enum export export_from_secname(struct elf_info *elf, unsigned int sec) { const char *secname = sec_name(elf, sec); if (strstarts(secname, "___ksymtab+")) return export_plain; else if (strstarts(secname, "___ksymtab_unused+")) return export_unused; else if (strstarts(secname, "___ksymtab_gpl+")) return export_gpl; else if (strstarts(secname, "___ksymtab_unused_gpl+")) return export_unused_gpl; else if (strstarts(secname, "___ksymtab_gpl_future+")) return export_gpl_future; else return export_unknown; } static enum export export_from_sec(struct elf_info *elf, unsigned int sec) { if (sec == elf->export_sec) return export_plain; else if (sec == elf->export_unused_sec) return export_unused; else if (sec == elf->export_gpl_sec) return export_gpl; else if (sec == elf->export_unused_gpl_sec) return export_unused_gpl; else if (sec == elf->export_gpl_future_sec) return export_gpl_future; else return export_unknown; } static const char *namespace_from_kstrtabns(const struct elf_info *info, const Elf_Sym *sym) { const char *value = sym_get_data(info, sym); return value[0] ? value : NULL; } static void sym_update_namespace(const char *symname, const char *namespace) { struct symbol *s = find_symbol(symname); /* * That symbol should have been created earlier and thus this is * actually an assertion. */ if (!s) { merror("Could not update namespace(%s) for symbol %s\n", namespace, symname); return; } free(s->namespace); s->namespace = namespace && namespace[0] ? NOFAIL(strdup(namespace)) : NULL; } /** * Add an exported symbol - it may have already been added without a * CRC, in this case just update the CRC **/ static struct symbol *sym_add_exported(const char *name, struct module *mod, enum export export) { struct symbol *s = find_symbol(name); if (!s) { s = new_symbol(name, mod, export); } else if (!external_module || s->module->is_vmlinux || s->module == mod) { warn("%s: '%s' exported twice. Previous export was in %s%s\n", mod->name, name, s->module->name, s->module->is_vmlinux ? "" : ".ko"); return s; } s->module = mod; s->export = export; return s; } static void sym_set_crc(const char *name, unsigned int crc) { struct symbol *s = find_symbol(name); /* * Ignore stand-alone __crc_*, which might be auto-generated symbols * such as __*_veneer in ARM ELF. */ if (!s) return; s->crc = crc; s->crc_valid = 1; } static void *grab_file(const char *filename, size_t *size) { struct stat st; void *map = MAP_FAILED; int fd; fd = open(filename, O_RDONLY); if (fd < 0) return NULL; if (fstat(fd, &st)) goto failed; *size = st.st_size; map = mmap(NULL, *size, PROT_READ|PROT_WRITE, MAP_PRIVATE, fd, 0); failed: close(fd); if (map == MAP_FAILED) return NULL; return map; } static void release_file(void *file, size_t size) { munmap(file, size); } static int parse_elf(struct elf_info *info, const char *filename) { unsigned int i; Elf_Ehdr *hdr; Elf_Shdr *sechdrs; Elf_Sym *sym; const char *secstrings; unsigned int symtab_idx = ~0U, symtab_shndx_idx = ~0U; hdr = grab_file(filename, &info->size); if (!hdr) { if (ignore_missing_files) { fprintf(stderr, "%s: %s (ignored)\n", filename, strerror(errno)); return 0; } perror(filename); exit(1); } info->hdr = hdr; if (info->size < sizeof(*hdr)) { /* file too small, assume this is an empty .o file */ return 0; } /* Is this a valid ELF file? */ if ((hdr->e_ident[EI_MAG0] != ELFMAG0) || (hdr->e_ident[EI_MAG1] != ELFMAG1) || (hdr->e_ident[EI_MAG2] != ELFMAG2) ||