1/* Postprocess module symbol versions
   2 *
   3 * Copyright 2003       Kai Germaschewski
   4 * Copyright 2002-2004  Rusty Russell, IBM Corporation
   5 * Copyright 2006-2008  Sam Ravnborg
   6 * Based in part on module-init-tools/depmod.c,file2alias
   7 *
   8 * This software may be used and distributed according to the terms
   9 * of the GNU General Public License, incorporated herein by reference.
  10 *
  11 * Usage: modpost vmlinux module1.o module2.o ...
  12 */
  13
  14#define _GNU_SOURCE
 
 
  15#include <stdio.h>
  16#include <ctype.h>
  17#include <string.h>
  18#include <limits.h>
  19#include <stdbool.h>
  20#include <errno.h>
  21#include "modpost.h"
  22#include "../../include/generated/autoconf.h"
  23#include "../../include/linux/license.h"
  24#include "../../include/linux/export.h"
  25
 
  26/* Are we using CONFIG_MODVERSIONS? */
  27static int modversions = 0;
  28/* Warn about undefined symbols? (do so if we have vmlinux) */
  29static int have_vmlinux = 0;
  30/* Is CONFIG_MODULE_SRCVERSION_ALL set? */
  31static int all_versions = 0;
  32/* If we are modposting external module set to 1 */
  33static int external_module = 0;
  34/* Warn about section mismatch in vmlinux if set to 1 */
  35static int vmlinux_section_warnings = 1;
  36/* Only warn about unresolved symbols */
  37static int warn_unresolved = 0;
  38/* How a symbol is exported */
  39static int sec_mismatch_count = 0;
  40static int sec_mismatch_verbose = 1;
  41static int sec_mismatch_fatal = 0;
  42/* ignore missing files */
  43static int ignore_missing_files;
  44
  45enum export {
  46	export_plain,      export_unused,     export_gpl,
  47	export_unused_gpl, export_gpl_future, export_unknown
  48};
  49
  50#define PRINTF __attribute__ ((format (printf, 1, 2)))
  51
  52PRINTF void fatal(const char *fmt, ...)
  53{
  54	va_list arglist;
  55
  56	fprintf(stderr, "FATAL: ");
 
 
 
  57
  58	va_start(arglist, fmt);
  59	vfprintf(stderr, fmt, arglist);
  60	va_end(arglist);
  61
  62	exit(1);
  63}
  64
  65PRINTF void warn(const char *fmt, ...)
  66{
  67	va_list arglist;
 
 
 
  68
  69	fprintf(stderr, "WARNING: ");
 
 
  70
  71	va_start(arglist, fmt);
  72	vfprintf(stderr, fmt, arglist);
  73	va_end(arglist);
  74}
  75
  76PRINTF void merror(const char *fmt, ...)
  77{
  78	va_list arglist;
  79
  80	fprintf(stderr, "ERROR: ");
 
 
 
 
 
 
 
 
 
 
 
 
  81
  82	va_start(arglist, fmt);
  83	vfprintf(stderr, fmt, arglist);
  84	va_end(arglist);
  85}
  86
  87static inline bool strends(const char *str, const char *postfix)
  88{
  89	if (strlen(str) < strlen(postfix))
  90		return false;
  91
  92	return strcmp(str + strlen(str) - strlen(postfix), postfix) == 0;
  93}
  94
  95static int is_vmlinux(const char *modname)
  96{
  97	const char *myname;
 
  98
  99	myname = strrchr(modname, '/');
 100	if (myname)
 101		myname++;
 102	else
 103		myname = modname;
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 104
 105	return (strcmp(myname, "vmlinux") == 0) ||
 106	       (strcmp(myname, "vmlinux.o") == 0);
 
 
 
 
 
 107}
 108
 109void *do_nofail(void *ptr, const char *expr)
 110{
 111	if (!ptr)
 112		fatal("modpost: Memory allocation failure: %s.\n", expr);
 113
 114	return ptr;
 
 
 
 
 
 
 
 
 
 
 
 115}
 116
 117/* A list of all modules we processed */
 118static struct module *modules;
 119
 120static struct module *find_module(char *modname)
 121{
 122	struct module *mod;
 123
 124	for (mod = modules; mod; mod = mod->next)
 125		if (strcmp(mod->name, modname) == 0)
 126			break;
 127	return mod;
 
 128}
 129
 130static struct module *new_module(const char *modname)
 131{
 132	struct module *mod;
 133	char *p;
 134
 135	mod = NOFAIL(malloc(sizeof(*mod)));
 136	memset(mod, 0, sizeof(*mod));
 137	p = NOFAIL(strdup(modname));
 138
 139	/* strip trailing .o */
 140	if (strends(p, ".o")) {
 141		p[strlen(p) - 2] = '\0';
 142		mod->is_dot_o = 1;
 143	}
 
 
 
 
 
 
 
 
 
 
 144
 145	/* add to list */
 146	mod->name = p;
 147	mod->gpl_compatible = -1;
 148	mod->next = modules;
 149	modules = mod;
 150
 151	return mod;
 152}
 153
 154/* A hash of all exported symbols,
 155 * struct symbol is also used for lists of unresolved symbols */
 156
 157#define SYMBOL_HASH_SIZE 1024
 158
 159struct symbol {
 160	struct symbol *next;
 
 161	struct module *module;
 
 162	unsigned int crc;
 163	int crc_valid;
 164	unsigned int weak:1;
 165	unsigned int vmlinux:1;    /* 1 if symbol is defined in vmlinux */
 166	unsigned int kernel:1;     /* 1 if symbol is from kernel
 167				    *  (only for external modules) **/
 168	unsigned int preloaded:1;  /* 1 if symbol from Module.symvers, or crc */
 169	enum export  export;       /* Type of export */
 170	char name[0];
 171};
 172
 173static struct symbol *symbolhash[SYMBOL_HASH_SIZE];
 174
 175/* This is based on the hash agorithm from gdbm, via tdb */
 176static inline unsigned int tdb_hash(const char *name)
 177{
 178	unsigned value;	/* Used to compute the hash value.  */
 179	unsigned   i;	/* Used to cycle through random values. */
 180
 181	/* Set the initial value from the key size. */
 182	for (value = 0x238F13AF * strlen(name), i = 0; name[i]; i++)
 183		value = (value + (((unsigned char *)name)[i] << (i*5 % 24)));
 184
 185	return (1103515243 * value + 12345);
 186}
 187
 188/**
 189 * Allocate a new symbols for use in the hash of exported symbols or
 190 * the list of unresolved symbols per module
 191 **/
 192static struct symbol *alloc_symbol(const char *name, unsigned int weak,
 193				   struct symbol *next)
 194{
 195	struct symbol *s = NOFAIL(malloc(sizeof(*s) + strlen(name) + 1));
 196
 197	memset(s, 0, sizeof(*s));
 198	strcpy(s->name, name);
 199	s->weak = weak;
 200	s->next = next;
 201	return s;
 202}
 203
 204/* For the hash of exported symbols */
 205static struct symbol *new_symbol(const char *name, struct module *module,
 206				 enum export export)
 207{
 208	unsigned int hash;
 209	struct symbol *new;
 210
 211	hash = tdb_hash(name) % SYMBOL_HASH_SIZE;
 212	new = symbolhash[hash] = alloc_symbol(name, 0, symbolhash[hash]);
 213	new->module = module;
 214	new->export = export;
 215	return new;
 216}
 217
 218static struct symbol *find_symbol(const char *name)
 
 
 
 
 
 
 
 
 
 
 219{
 220	struct symbol *s;
 221
 222	/* For our purposes, .foo matches foo.  PPC64 needs this. */
 223	if (name[0] == '.')
 224		name++;
 225
 226	for (s = symbolhash[tdb_hash(name) % SYMBOL_HASH_SIZE]; s; s = s->next) {
 227		if (strcmp(s->name, name) == 0)
 228			return s;
 229	}
 230	return NULL;
 231}
 232
 233static const struct {
 234	const char *str;
 235	enum export export;
 236} export_list[] = {
 237	{ .str = "EXPORT_SYMBOL",            .export = export_plain },
 238	{ .str = "EXPORT_UNUSED_SYMBOL",     .export = export_unused },
 239	{ .str = "EXPORT_SYMBOL_GPL",        .export = export_gpl },
 240	{ .str = "EXPORT_UNUSED_SYMBOL_GPL", .export = export_unused_gpl },
 241	{ .str = "EXPORT_SYMBOL_GPL_FUTURE", .export = export_gpl_future },
 242	{ .str = "(unknown)",                .export = export_unknown },
 243};
 244
 
 
 
 
 245
 246static const char *export_str(enum export ex)
 247{
 248	return export_list[ex].str;
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 249}
 250
 251static enum export export_no(const char *s)
 252{
 253	int i;
 254
 255	if (!s)
 256		return export_unknown;
 257	for (i = 0; export_list[i].export != export_unknown; i++) {
 258		if (strcmp(export_list[i].str, s) == 0)
 259			return export_list[i].export;
 260	}
 261	return export_unknown;
 262}
 263
 264static const char *sec_name(struct elf_info *elf, int secindex);
 
 
 
 265
 266#define strstarts(str, prefix) (strncmp(str, prefix, strlen(prefix)) == 0)
 
 267
 268static enum export export_from_secname(struct elf_info *elf, unsigned int sec)
 269{
 270	const char *secname = sec_name(elf, sec);
 
 
 271
 272	if (strstarts(secname, "___ksymtab+"))
 273		return export_plain;
 274	else if (strstarts(secname, "___ksymtab_unused+"))
 275		return export_unused;
 276	else if (strstarts(secname, "___ksymtab_gpl+"))
 277		return export_gpl;
 278	else if (strstarts(secname, "___ksymtab_unused_gpl+"))
 279		return export_unused_gpl;
 280	else if (strstarts(secname, "___ksymtab_gpl_future+"))
 281		return export_gpl_future;
 282	else
 283		return export_unknown;
 284}
 285
 286static enum export export_from_sec(struct elf_info *elf, unsigned int sec)
 287{
 288	if (sec == elf->export_sec)
 289		return export_plain;
 290	else if (sec == elf->export_unused_sec)
 291		return export_unused;
 292	else if (sec == elf->export_gpl_sec)
 293		return export_gpl;
 294	else if (sec == elf->export_unused_gpl_sec)
 295		return export_unused_gpl;
 296	else if (sec == elf->export_gpl_future_sec)
 297		return export_gpl_future;
 298	else
 299		return export_unknown;
 300}
 301
 302/**
 303 * Add an exported symbol - it may have already been added without a
 304 * CRC, in this case just update the CRC
 305 **/
 306static struct symbol *sym_add_exported(const char *name, struct module *mod,
 307				       enum export export)
 308{
 309	struct symbol *s = find_symbol(name);
 310
 311	if (!s) {
 312		s = new_symbol(name, mod, export);
 313	} else {
 314		if (!s->preloaded) {
 315			warn("%s: '%s' exported twice. Previous export "
 316			     "was in %s%s\n", mod->name, name,
 317			     s->module->name,
 318			     is_vmlinux(s->module->name) ?"":".ko");
 319		} else {
 320			/* In case Module.symvers was out of date */
 321			s->module = mod;
 322		}
 323	}
 324	s->preloaded = 0;
 325	s->vmlinux   = is_vmlinux(mod->name);
 326	s->kernel    = 0;
 327	s->export    = export;
 
 
 
 
 328	return s;
 329}
 330
 331static void sym_update_crc(const char *name, struct module *mod,
 332			   unsigned int crc, enum export export)
 333{
 334	struct symbol *s = find_symbol(name);
 335
 336	if (!s) {
 337		s = new_symbol(name, mod, export);
 338		/* Don't complain when we find it later. */
 339		s->preloaded = 1;
 340	}
 341	s->crc = crc;
 342	s->crc_valid = 1;
 343}
 344
 345void *grab_file(const char *filename, unsigned long *size)
 346{
 347	struct stat st;
 348	void *map = MAP_FAILED;
 349	int fd;
 350
 351	fd = open(filename, O_RDONLY);
 352	if (fd < 0)
 353		return NULL;
 354	if (fstat(fd, &st))
 355		goto failed;
 356
 357	*size = st.st_size;
 358	map = mmap(NULL, *size, PROT_READ|PROT_WRITE, MAP_PRIVATE, fd, 0);
 359
 360failed:
 361	close(fd);
 362	if (map == MAP_FAILED)
 363		return NULL;
 364	return map;
 365}
 366
 367/**
 368  * Return a copy of the next line in a mmap'ed file.
 369  * spaces in the beginning of the line is trimmed away.
 370  * Return a pointer to a static buffer.
 371  **/
 372char *get_next_line(unsigned long *pos, void *file, unsigned long size)
 373{
 374	static char line[4096];
 375	int skip = 1;
 376	size_t len = 0;
 377	signed char *p = (signed char *)file + *pos;
 378	char *s = line;
 379
 380	for (; *pos < size ; (*pos)++) {
 381		if (skip && isspace(*p)) {
 382			p++;
 383			continue;
 384		}
 385		skip = 0;
 386		if (*p != '\n' && (*pos < size)) {
 387			len++;
 388			*s++ = *p++;
 389			if (len > 4095)
 390				break; /* Too long, stop */
 391		} else {
 392			/* End of string */
 393			*s = '\0';
 394			return line;
 395		}
 396	}
 397	/* End of buffer */
 398	return NULL;
 399}
 400
 401void release_file(void *file, unsigned long size)
 402{
 403	munmap(file, size);
 404}
 405
 406static int parse_elf(struct elf_info *info, const char *filename)
 407{
 408	unsigned int i;
 409	Elf_Ehdr *hdr;
 410	Elf_Shdr *sechdrs;
 411	Elf_Sym  *sym;
 412	const char *secstrings;
 413	unsigned int symtab_idx = ~0U, symtab_shndx_idx = ~0U;
 414
 415	hdr = grab_file(filename, &info->size);
 416	if (!hdr) {
 417		if (ignore_missing_files) {
 418			fprintf(stderr, "%s: %s (ignored)\n", filename,
 419				strerror(errno));
 420			return 0;
 421		}
 422		perror(filename);
 423		exit(1);
 424	}
 425	info->hdr = hdr;
 426	if (info->size < sizeof(*hdr)) {
 427		/* file too small, assume this is an empty .o file */
 428		return 0;
 429	}
 430	/* Is this a valid ELF file? */
 431	if ((hdr->e_ident[EI_MAG0] != ELFMAG0) ||
 432	    (hdr->e_ident[EI_MAG1] != ELFMAG1) ||
 433	    (hdr->e_ident[EI_MAG2] != ELFMAG2) ||
 434	    (hdr->e_ident[EI_MAG3] != ELFMAG3)) {
 435		/* Not an ELF file - silently ignore it */
 436		return 0;
 437	}
 438	/* Fix endianness in ELF header */
 439	hdr->e_type      = TO_NATIVE(hdr->e_type);
 440	hdr->e_machine   = TO_NATIVE(hdr->e_machine);
 441	hdr->e_version   = TO_NATIVE(hdr->e_version);
 442	hdr->e_entry     = TO_NATIVE(hdr->e_entry);
 443	hdr->e_phoff     = TO_NATIVE(hdr->e_phoff);
 444	hdr->e_shoff     = TO_NATIVE(hdr->e_shoff);
 445	hdr->e_flags     = TO_NATIVE(hdr->e_flags);
 446	hdr->e_ehsize    = TO_NATIVE(hdr->e_ehsize);
 447	hdr->e_phentsize = TO_NATIVE(hdr->e_phentsize);
 448	hdr->e_phnum     = TO_NATIVE(hdr->e_phnum);
 449	hdr->e_shentsize = TO_NATIVE(hdr->e_shentsize);
 450	hdr->e_shnum     = TO_NATIVE(hdr->e_shnum);
 451	hdr->e_shstrndx  = TO_NATIVE(hdr->e_shstrndx);
 452	sechdrs = (void *)hdr + hdr->e_shoff;
 453	info->sechdrs = sechdrs;
 454
 
 
 
 
 455	/* Check if file offset is correct */
 456	if (hdr->e_shoff > info->size) {
 457		fatal("section header offset=%lu in file '%s' is bigger than "
 458		      "filesize=%lu\n", (unsigned long)hdr->e_shoff,
 459		      filename, info->size);
 460		return 0;
 461	}
 462
 463	if (hdr->e_shnum == SHN_UNDEF) {
 464		/*
 465		 * There are more than 64k sections,
 466		 * read count from .sh_size.
 467		 */
 468		info->num_sections = TO_NATIVE(sechdrs[0].sh_size);
 469	}
 470	else {
 471		info->num_sections = hdr->e_shnum;
 472	}
 473	if (hdr->e_shstrndx == SHN_XINDEX) {
 474		info->secindex_strings = TO_NATIVE(sechdrs[0].sh_link);
 475	}
 476	else {
 477		info->secindex_strings = hdr->e_shstrndx;
 478	}
 479
 480	/* Fix endianness in section headers */
 481	for (i = 0; i < info->num_sections; i++) {
 482		sechdrs[i].sh_name      = TO_NATIVE(sechdrs[i].sh_name);
 483		sechdrs[i].sh_type      = TO_NATIVE(sechdrs[i].sh_type);
 484		sechdrs[i].sh_flags     = TO_NATIVE(sechdrs[i].sh_flags);
 485		sechdrs[i].sh_addr      = TO_NATIVE(sechdrs[i].sh_addr);
 486		sechdrs[i].sh_offset    = TO_NATIVE(sechdrs[i].sh_offset);
 487		sechdrs[i].sh_size      = TO_NATIVE(sechdrs[i].sh_size);
 488		sechdrs[i].sh_link      = TO_NATIVE(sechdrs[i].sh_link);
 489		sechdrs[i].sh_info      = TO_NATIVE(sechdrs[i].sh_info);
 490		sechdrs[i].sh_addralign = TO_NATIVE(sechdrs[i].sh_addralign);
 491		sechdrs[i].sh_entsize   = TO_NATIVE(sechdrs[i].sh_entsize);
 492	}
 493	/* Find symbol table. */
 494	secstrings = (void *)hdr + sechdrs[info->secindex_strings].sh_offset;
 495	for (i = 1; i < info->num_sections; i++) {
 496		const char *secname;
 497		int nobits = sechdrs[i].sh_type == SHT_NOBITS;
 498
 499		if (!nobits && sechdrs[i].sh_offset > info->size) {
 500			fatal("%s is truncated. sechdrs[i].sh_offset=%lu > "
 501			      "sizeof(*hrd)=%zu\n", filename,
 502			      (unsigned long)sechdrs[i].sh_offset,
 503			      sizeof(*hdr));
 504			return 0;
 505		}
 506		secname = secstrings + sechdrs[i].sh_name;
 507		if (strcmp(secname, ".modinfo") == 0) {
 508			if (nobits)
 509				fatal("%s has NOBITS .modinfo\n", filename);
 510			info->modinfo = (void *)hdr + sechdrs[i].sh_offset;
 511			info->modinfo_len = sechdrs[i].sh_size;
 512		} else if (strcmp(secname, "__ksymtab") == 0)
 513			info->export_sec = i;
 514		else if (strcmp(secname, "__ksymtab_unused") == 0)
 515			info->export_unused_sec = i;
 516		else if (strcmp(secname, "__ksymtab_gpl") == 0)
 517			info->export_gpl_sec = i;
 518		else if (strcmp(secname, "__ksymtab_unused_gpl") == 0)
 519			info->export_unused_gpl_sec = i;
 520		else if (strcmp(secname, "__ksymtab_gpl_future") == 0)
 521			info->export_gpl_future_sec = i;
 522
 523		if (sechdrs[i].sh_type == SHT_SYMTAB) {
 524			unsigned int sh_link_idx;
 525			symtab_idx = i;
 526			info->symtab_start = (void *)hdr +
 527			    sechdrs[i].sh_offset;
 528			info->symtab_stop  = (void *)hdr +
 529			    sechdrs[i].sh_offset + sechdrs[i].sh_size;
 530			sh_link_idx = sechdrs[i].sh_link;
 531			info->strtab       = (void *)hdr +
 532			    sechdrs[sh_link_idx].sh_offset;
 533		}
 534
 535		/* 32bit section no. table? ("more than 64k sections") */
 536		if (sechdrs[i].sh_type == SHT_SYMTAB_SHNDX) {
 537			symtab_shndx_idx = i;
 538			info->symtab_shndx_start = (void *)hdr +
 539			    sechdrs[i].sh_offset;
 540			info->symtab_shndx_stop  = (void *)hdr +
 541			    sechdrs[i].sh_offset + sechdrs[i].sh_size;
 542		}
 543	}
 544	if (!info->symtab_start)
 545		fatal("%s has no symtab?\n", filename);
 546
 547	/* Fix endianness in symbols */
 548	for (sym = info->symtab_start; sym < info->symtab_stop; sym++) {
 549		sym->st_shndx = TO_NATIVE(sym->st_shndx);
 550		sym->st_name  = TO_NATIVE(sym->st_name);
 551		sym->st_value = TO_NATIVE(sym->st_value);
 552		sym->st_size  = TO_NATIVE(sym->st_size);
 553	}
 554
 555	if (symtab_shndx_idx != ~0U) {
 556		Elf32_Word *p;
 557		if (symtab_idx != sechdrs[symtab_shndx_idx].sh_link)
 558			fatal("%s: SYMTAB_SHNDX has bad sh_link: %u!=%u\n",
 559			      filename, sechdrs[symtab_shndx_idx].sh_link,
 560			      symtab_idx);
 561		/* Fix endianness */
 562		for (p = info->symtab_shndx_start; p < info->symtab_shndx_stop;
 563		     p++)
 564			*p = TO_NATIVE(*p);
 565	}
 566
 
 
 567	return 1;
 568}
 569
 570static void parse_elf_finish(struct elf_info *info)
 571{
 
 572	release_file(info->hdr, info->size);
 573}
 574
 575static int ignore_undef_symbol(struct elf_info *info, const char *symname)
 576{
 577	/* ignore __this_module, it will be resolved shortly */
 578	if (strcmp(symname, VMLINUX_SYMBOL_STR(__this_module)) == 0)
 579		return 1;
 580	/* ignore global offset table */
 581	if (strcmp(symname, "_GLOBAL_OFFSET_TABLE_") == 0)
 582		return 1;
 583	if (info->hdr->e_machine == EM_PPC)
 584		/* Special register function linked on all modules during final link of .ko */
 585		if (strncmp(symname, "_restgpr_", sizeof("_restgpr_") - 1) == 0 ||
 586		    strncmp(symname, "_savegpr_", sizeof("_savegpr_") - 1) == 0 ||
 587		    strncmp(symname, "_rest32gpr_", sizeof("_rest32gpr_") - 1) == 0 ||
 588		    strncmp(symname, "_save32gpr_", sizeof("_save32gpr_") - 1) == 0 ||
 589		    strncmp(symname, "_restvr_", sizeof("_restvr_") - 1) == 0 ||
 590		    strncmp(symname, "_savevr_", sizeof("_savevr_") - 1) == 0)
 591			return 1;
 592	if (info->hdr->e_machine == EM_PPC64)
 593		/* Special register function linked on all modules during final link of .ko */
 594		if (strncmp(symname, "_restgpr0_", sizeof("_restgpr0_") - 1) == 0 ||
 595		    strncmp(symname, "_savegpr0_", sizeof("_savegpr0_") - 1) == 0 ||
 596		    strncmp(symname, "_restvr_", sizeof("_restvr_") - 1) == 0 ||
 597		    strncmp(symname, "_savevr_", sizeof("_savevr_") - 1) == 0 ||
 598		    strcmp(symname, ".TOC.") == 0)
 599			return 1;
 
 
 
 
 
 600	/* Do not ignore this symbol */
 601	return 0;
 602}
 603
 604#define CRC_PFX     VMLINUX_SYMBOL_STR(__crc_)
 605#define KSYMTAB_PFX VMLINUX_SYMBOL_STR(__ksymtab_)
 606
 607static void handle_modversions(struct module *mod, struct elf_info *info,
 608			       Elf_Sym *sym, const char *symname)
 609{
 610	unsigned int crc;
 611	enum export export;
 612	bool is_crc = false;
 613
 614	if ((!is_vmlinux(mod->name) || mod->is_dot_o) &&
 615	    strncmp(symname, "__ksymtab", 9) == 0)
 616		export = export_from_secname(info, get_secindex(info, sym));
 617	else
 618		export = export_from_sec(info, get_secindex(info, sym));
 619
 620	/* CRC'd symbol */
 621	if (strncmp(symname, CRC_PFX, strlen(CRC_PFX)) == 0) {
 622		is_crc = true;
 623		crc = (unsigned int) sym->st_value;
 624		if (sym->st_shndx != SHN_UNDEF && sym->st_shndx != SHN_ABS) {
 625			unsigned int *crcp;
 626
 627			/* symbol points to the CRC in the ELF object */
 628			crcp = (void *)info->hdr + sym->st_value +
 629			       info->sechdrs[sym->st_shndx].sh_offset -
 630			       (info->hdr->e_type != ET_REL ?
 631				info->sechdrs[sym->st_shndx].sh_addr : 0);
 632			crc = *crcp;
 633		}
 634		sym_update_crc(symname + strlen(CRC_PFX), mod, crc,
 635				export);
 636	}
 637
 638	switch (sym->st_shndx) {
 639	case SHN_COMMON:
 640		if (!strncmp(symname, "__gnu_lto_", sizeof("__gnu_lto_")-1)) {
 641			/* Should warn here, but modpost runs before the linker */
 642		} else
 643			warn("\"%s\" [%s] is COMMON symbol\n", symname, mod->name);
 644		break;
 645	case SHN_UNDEF:
 646		/* undefined symbol */
 647		if (ELF_ST_BIND(sym->st_info) != STB_GLOBAL &&
 648		    ELF_ST_BIND(sym->st_info) != STB_WEAK)
 649			break;
 650		if (ignore_undef_symbol(info, symname))
 651			break;
 652/* cope with newer glibc (2.3.4 or higher) STT_ definition in elf.h */
 653#if defined(STT_REGISTER) || defined(STT_SPARC_REGISTER)
 654/* add compatibility with older glibc */
 655#ifndef STT_SPARC_REGISTER
 656#define STT_SPARC_REGISTER STT_REGISTER
 657#endif
 658		if (info->hdr->e_machine == EM_SPARC ||
 659		    info->hdr->e_machine == EM_SPARCV9) {
 660			/* Ignore register directives. */
 661			if (ELF_ST_TYPE(sym->st_info) == STT_SPARC_REGISTER)
 662				break;
 663			if (symname[0] == '.') {
 664				char *munged = strdup(symname);
 665				munged[0] = '_';
 666				munged[1] = toupper(munged[1]);
 667				symname = munged;
 668			}
 669		}
 670#endif
 671
 672#ifdef CONFIG_HAVE_UNDERSCORE_SYMBOL_PREFIX
 673		if (symname[0] != '_')
 674			break;
 675		else
 676			symname++;
 677#endif
 678		if (is_crc) {
 679			const char *e = is_vmlinux(mod->name) ?"":".ko";
 680			warn("EXPORT symbol \"%s\" [%s%s] version generation failed, symbol will not be versioned.\n", symname + strlen(CRC_PFX), mod->name, e);
 681		}
 682		mod->unres = alloc_symbol(symname,
 683					  ELF_ST_BIND(sym->st_info) == STB_WEAK,
 684					  mod->unres);
 685		break;
 686	default:
 687		/* All exported symbols */
 688		if (strncmp(symname, KSYMTAB_PFX, strlen(KSYMTAB_PFX)) == 0) {
 689			sym_add_exported(symname + strlen(KSYMTAB_PFX), mod,
 690					export);
 691		}
 692		if (strcmp(symname, VMLINUX_SYMBOL_STR(init_module)) == 0)
 693			mod->has_init = 1;
 694		if (strcmp(symname, VMLINUX_SYMBOL_STR(cleanup_module)) == 0)
 695			mod->has_cleanup = 1;
 696		break;
 697	}
 698}
 699
 700/**
 701 * Parse tag=value strings from .modinfo section
 702 **/
 703static char *next_string(char *string, unsigned long *secsize)
 704{
 705	/* Skip non-zero chars */
 706	while (string[0]) {
 707		string++;
 708		if ((*secsize)-- <= 1)
 709			return NULL;
 710	}
 711
 712	/* Skip any zero padding. */
 713	while (!string[0]) {
 714		string++;
 715		if ((*secsize)-- <= 1)
 716			return NULL;
 717	}
 718	return string;
 719}
 720
 721static char *get_next_modinfo(void *modinfo, unsigned long modinfo_len,
 722			      const char *tag, char *info)
 723{
 724	char *p;
 725	unsigned int taglen = strlen(tag);
 726	unsigned long size = modinfo_len;
 
 727
 728	if (info) {
 729		size -= info - (char *)modinfo;
 730		modinfo = next_string(info, &size);
 731	}
 732
 733	for (p = modinfo; p; p = next_string(p, &size)) {
 734		if (strncmp(p, tag, taglen) == 0 && p[taglen] == '=')
 735			return p + taglen + 1;
 736	}
 737	return NULL;
 738}
 739
 740static char *get_modinfo(void *modinfo, unsigned long modinfo_len,
 741			 const char *tag)
 742
 743{
 744	return get_next_modinfo(modinfo, modinfo_len, tag, NULL);
 745}
 746
 747/**
 748 * Test if string s ends in string sub
 749 * return 0 if match
 750 **/
 751static int strrcmp(const char *s, const char *sub)
 752{
 753	int slen, sublen;
 754
 755	if (!s || !sub)
 756		return 1;
 757
 758	slen = strlen(s);
 759	sublen = strlen(sub);
 760
 761	if ((slen == 0) || (sublen == 0))
 762		return 1;
 763
 764	if (sublen > slen)
 765		return 1;
 766
 767	return memcmp(s + slen - sublen, sub, sublen);
 768}
 769
 770static const char *sym_name(struct elf_info *elf, Elf_Sym *sym)
 771{
 772	if (sym)
 773		return elf->strtab + sym->st_name;
 774	else
 775		return "(unknown)";
 776}
 777
 778static const char *sec_name(struct elf_info *elf, int secindex)
 779{
 780	Elf_Shdr *sechdrs = elf->sechdrs;
 781	return (void *)elf->hdr +
 782		elf->sechdrs[elf->secindex_strings].sh_offset +
 783		sechdrs[secindex].sh_name;
 784}
 785
 786static const char *sech_name(struct elf_info *elf, Elf_Shdr *sechdr)
 787{
 788	return (void *)elf->hdr +
 789		elf->sechdrs[elf->secindex_strings].sh_offset +
 790		sechdr->sh_name;
 791}
 792
 793/* The pattern is an array of simple patterns.
 794 * "foo" will match an exact string equal to "foo"
 795 * "*foo" will match a string that ends with "foo"
 796 * "foo*" will match a string that begins with "foo"
 797 * "*foo*" will match a string that contains "foo"
 798 */
 799static int match(const char *sym, const char * const pat[])
 800{
 801	const char *p;
 802	while (*pat) {
 803		p = *pat++;
 804		const char *endp = p + strlen(p) - 1;
 805
 806		/* "*foo*" */
 807		if (*p == '*' && *endp == '*') {
 808			char *here, *bare = strndup(p + 1, strlen(p) - 2);
 809
 810			here = strstr(sym, bare);
 811			free(bare);
 812			if (here != NULL)
 813				return 1;
 814		}
 815		/* "*foo" */
 816		else if (*p == '*') {
 817			if (strrcmp(sym, p + 1) == 0)
 818				return 1;
 819		}
 820		/* "foo*" */
 821		else if (*endp == '*') {
 822			if (strncmp(sym, p, strlen(p) - 1) == 0)
 823				return 1;
 824		}
 825		/* no wildcards */
 826		else {
 827			if (strcmp(p, sym) == 0)
 828				return 1;
 829		}
 830	}
 831	/* no match */
 832	return 0;
 833}
 834
 
 
 
 
 
 
 
 835/* sections that we do not want to do full section mismatch check on */
 836static const char *const section_white_list[] =
 837{
 838	".comment*",
 839	".debug*",
 840	".cranges",		/* sh64 */
 841	".zdebug*",		/* Compressed debug sections. */
 842	".GCC-command-line",	/* mn10300 */
 843	".GCC.command.line",	/* record-gcc-switches, non mn10300 */
 844	".mdebug*",        /* alpha, score, mips etc. */
 845	".pdr",            /* alpha, score, mips etc. */
 846	".stab*",
 847	".note*",
 848	".got*",
 849	".toc*",
 850	".xt.prop",				 /* xtensa */
 851	".xt.lit",         /* xtensa */
 852	".arcextmap*",			/* arc */
 853	".gnu.linkonce.arcext*",	/* arc : modules */
 854	".cmem*",			/* EZchip */
 855	".fmt_slot*",			/* EZchip */
 856	".gnu.lto*",
 
 
 857	NULL
 858};
 859
 860/*
 861 * This is used to find sections missing the SHF_ALLOC flag.
 862 * The cause of this is often a section specified in assembler
 863 * without "ax" / "aw".
 864 */
 865static void check_section(const char *modname, struct elf_info *elf,
 866			  Elf_Shdr *sechdr)
 867{
 868	const char *sec = sech_name(elf, sechdr);
 869
 870	if (sechdr->sh_type == SHT_PROGBITS &&
 871	    !(sechdr->sh_flags & SHF_ALLOC) &&
 872	    !match(sec, section_white_list)) {
 873		warn("%s (%s): unexpected non-allocatable section.\n"
 874		     "Did you forget to use \"ax\"/\"aw\" in a .S file?\n"
 875		     "Note that for example <linux/init.h> contains\n"
 876		     "section definitions for use in .S files.\n\n",
 877		     modname, sec);
 878	}
 879}
 880
 881
 882
 883#define ALL_INIT_DATA_SECTIONS \
 884	".init.setup", ".init.rodata", ".meminit.rodata", \
 885	".init.data", ".meminit.data"
 886#define ALL_EXIT_DATA_SECTIONS \
 887	".exit.data", ".memexit.data"
 888
 889#define ALL_INIT_TEXT_SECTIONS \
 890	".init.text", ".meminit.text"
 891#define ALL_EXIT_TEXT_SECTIONS \
 892	".exit.text", ".memexit.text"
 893
 894#define ALL_PCI_INIT_SECTIONS	\
 895	".pci_fixup_early", ".pci_fixup_header", ".pci_fixup_final", \
 896	".pci_fixup_enable", ".pci_fixup_resume", \
 897	".pci_fixup_resume_early", ".pci_fixup_suspend"
 898
 899#define ALL_XXXINIT_SECTIONS MEM_INIT_SECTIONS
 900#define ALL_XXXEXIT_SECTIONS MEM_EXIT_SECTIONS
 901
 902#define ALL_INIT_SECTIONS INIT_SECTIONS, ALL_XXXINIT_SECTIONS
 903#define ALL_EXIT_SECTIONS EXIT_SECTIONS, ALL_XXXEXIT_SECTIONS
 904
 905#define DATA_SECTIONS ".data", ".data.rel"
 906#define TEXT_SECTIONS ".text", ".text.unlikely", ".sched.text", \
 907		".kprobes.text", ".cpuidle.text"
 
 908#define OTHER_TEXT_SECTIONS ".ref.text", ".head.text", ".spinlock.text", \
 909		".fixup", ".entry.text", ".exception.text", ".text.*", \
 910		".coldtext"
 911
 912#define INIT_SECTIONS      ".init.*"
 913#define MEM_INIT_SECTIONS  ".meminit.*"
 914
 915#define EXIT_SECTIONS      ".exit.*"
 916#define MEM_EXIT_SECTIONS  ".memexit.*"
 917
 918#define ALL_TEXT_SECTIONS  ALL_INIT_TEXT_SECTIONS, ALL_EXIT_TEXT_SECTIONS, \
 919		TEXT_SECTIONS, OTHER_TEXT_SECTIONS
 920
 921/* init data sections */
 922static const char *const init_data_sections[] =
 923	{ ALL_INIT_DATA_SECTIONS, NULL };
 924
 925/* all init sections */
 926static const char *const init_sections[] = { ALL_INIT_SECTIONS, NULL };
 927
 928/* All init and exit sections (code + data) */
 929static const char *const init_exit_sections[] =
 930	{ALL_INIT_SECTIONS, ALL_EXIT_SECTIONS, NULL };
 931
 932/* all text sections */
 933static const char *const text_sections[] = { ALL_TEXT_SECTIONS, NULL };
 934
 935/* data section */
 936static const char *const data_sections[] = { DATA_SECTIONS, NULL };
 937
 938
 939/* symbols in .data that may refer to init/exit sections */
 940#define DEFAULT_SYMBOL_WHITE_LIST					\
 941	"*driver",							\
 942	"*_template", /* scsi uses *_template a lot */			\
 943	"*_timer",    /* arm uses ops structures named _timer a lot */	\
 944	"*_sht",      /* scsi also used *_sht to some extent */		\
 945	"*_ops",							\
 946	"*_probe",							\
 947	"*_probe_one",							\
 948	"*_console"
 949
 950static const char *const head_sections[] = { ".head.text*", NULL };
 951static const char *const linker_symbols[] =
 952	{ "__init_begin", "_sinittext", "_einittext", NULL };
 953static const char *const optim_symbols[] = { "*.constprop.*", NULL };
 954
 955enum mismatch {
 956	TEXT_TO_ANY_INIT,
 957	DATA_TO_ANY_INIT,
 958	TEXT_TO_ANY_EXIT,
 959	DATA_TO_ANY_EXIT,
 960	XXXINIT_TO_SOME_INIT,
 961	XXXEXIT_TO_SOME_EXIT,
 962	ANY_INIT_TO_ANY_EXIT,
 963	ANY_EXIT_TO_ANY_INIT,
 964	EXPORT_TO_INIT_EXIT,
 965	EXTABLE_TO_NON_TEXT,
 966};
 967
 968/**
 969 * Describe how to match sections on different criterias:
 970 *
 971 * @fromsec: Array of sections to be matched.
 972 *
 973 * @bad_tosec: Relocations applied to a section in @fromsec to a section in
 974 * this array is forbidden (black-list).  Can be empty.
 975 *
 976 * @good_tosec: Relocations applied to a section in @fromsec must be
 977 * targetting sections in this array (white-list).  Can be empty.
 978 *
 979 * @mismatch: Type of mismatch.
 980 *
 981 * @symbol_white_list: Do not match a relocation to a symbol in this list
 982 * even if it is targetting a section in @bad_to_sec.
 983 *
 984 * @handler: Specific handler to call when a match is found.  If NULL,
 985 * default_mismatch_handler() will be called.
 986 *
 987 */
 988struct sectioncheck {
 989	const char *fromsec[20];
 990	const char *bad_tosec[20];
 991	const char *good_tosec[20];
 992	enum mismatch mismatch;
 993	const char *symbol_white_list[20];
 994	void (*handler)(const char *modname, struct elf_info *elf,
 995			const struct sectioncheck* const mismatch,
 996			Elf_Rela *r, Elf_Sym *sym, const char *fromsec);
 997
 998};
 999
1000static 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
1005static 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
1095static 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 **/
1176static 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 *  **/
1223static 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
1259static 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 */
1274static 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 **/
1289static 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*/
1327static 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
1354static 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
1362static 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
1375static 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 */
1389static 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
1531static 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
1562static 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 */
1574static unsigned int extable_entry_size = 0;
1575static 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
1590static 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
1607static 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
1645static 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
1683static 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
1699static 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
1709static 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
1745static 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
1772static 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
1795static 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
1841static 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 **/
1913static 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
1930static 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
1942static 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
2007static 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
2034void __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
2047void 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
2057static 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
2082static 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
2098static 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 **/
2121static 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
2142static 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
2148static 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 **/
2164static 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
2220static 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
2255static 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
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
2264static 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 **/
2311static 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;
2354fail:
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 **/
2363static 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
2372static 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
2393struct ext_sym_list {
2394	struct ext_sym_list *next;
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
2395	const char *file;
2396};
2397
2398int 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}