/* 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;/* Warn about section mismatch in vmlinux if set to 1 */static int vmlinux_section_warnings = 1;/* 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; 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)) #define PRINTF __attribute__ ((format (printf, 1, 2))) PRINTF void fatal(const char *fmt, ...){	va_list arglist; 	fprintf(stderr, "FATAL: "); 	va_start(arglist, fmt);	vfprintf(stderr, fmt, arglist);	va_end(arglist); 	exit(1);} PRINTF void warn(const char *fmt, ...){	va_list arglist; 	fprintf(stderr, "WARNING: "); 	va_start(arglist, fmt);	vfprintf(stderr, fmt, arglist);	va_end(arglist);} PRINTF void merror(const char *fmt, ...){	va_list arglist; 	fprintf(stderr, "ERROR: "); 	va_start(arglist, fmt);	vfprintf(stderr, fmt, arglist);	va_end(arglist);} 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;} static int is_vmlinux(const char *modname){	const char *myname; 	myname = strrchr(modname, '/');	if (myname)		myname++;	else		myname = modname; 	return (strcmp(myname, "vmlinux") == 0) ||	       (strcmp(myname, "vmlinux.o") == 0);} void *do_nofail(void *ptr, const char *expr){	if (!ptr)		fatal("modpost: Memory allocation failure: %s.\n", expr); 	return ptr;} /* 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;	char *p; 	mod = NOFAIL(malloc(sizeof(*mod)));	memset(mod, 0, sizeof(*mod));	p = NOFAIL(strdup(modname)); 	/* strip trailing .o */	if (strends(p, ".o")) {		p[strlen(p) - 2] = '\0';		mod->is_dot_o = 1;	} 	/* add to list */	mod->name = p;	mod->gpl_compatible = -1;	mod->next = modules;	modules = mod; 	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 vmlinux:1;    /* 1 if symbol is defined in vmlinux */	unsigned int kernel:1;     /* 1 if symbol is from kernel				    *  (only for external modules) **/	unsigned int is_static:1;  /* 1 if symbol is not global */	enum export  export;       /* Type of export */	char name[0];}; 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 const char *sech_name(struct elf_info *elf, Elf_Shdr *sechdr){	return (void *)elf->hdr +		elf->sechdrs[elf->secindex_strings].sh_offset +		sechdr->sh_name;} static const char *sec_name(struct elf_info *elf, int secindex){	return sech_name(elf, &elf->sechdrs[secindex]);} static void *sym_get_data(const struct elf_info *info, const Elf_Sym *sym){	Elf_Shdr *sechdr = &info->sechdrs[sym->st_shndx];	unsigned long offset; 	offset = sym->st_value;	if (info->hdr->e_type != ET_REL)		offset -= sechdr->sh_addr; 	return (void *)info->hdr + sechdr->sh_offset + offset;} #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 || is_vmlinux(s->module->name) ||		   s->module == mod) {		warn("%s: '%s' exported twice. Previous export was in %s%s\n",		     mod->name, name, s->module->name,		     is_vmlinux(s->module->name) ? "" : ".ko");		return s;	} 	s->module = mod;	s->vmlinux   = is_vmlinux(mod->name);	s->kernel    = 0;	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;} void *grab_file(const char *filename, unsigned long *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;} /**  * Return a copy of the next line in a mmap'ed file.  * spaces in the beginning of the line is trimmed away.  * Return a pointer to a static buffer.  **/char *get_next_line(unsigned long *pos, void *file, unsigned long size){	static char line[4096];	int skip = 1;	size_t len = 0;	signed char *p = (signed char *)file + *pos;	char *s = line; 	for (; *pos < size ; (*pos)++) {		if (skip && isspace(*p)) {			p++;			continue;		}		skip = 0;		if (*p != '\n' && (*pos < size)) {			len++;			*s++ = *p++;			if (len > 4095)				break; /* Too long, stop */		} else {			/* End of string */			*s = '\0';			return line;		}	}	/* End of buffer */	return NULL;} void release_file(void *file, unsigned long 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;		}

Lines 1–500 of 2679. Load more