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
 613	if ((!is_vmlinux(mod->name) || mod->is_dot_o) &&
 614	    strncmp(symname, "__ksymtab", 9) == 0)
 615		export = export_from_secname(info, get_secindex(info, sym));
 616	else
 617		export = export_from_sec(info, get_secindex(info, sym));
 618
 619	/* CRC'd symbol */
 620	if (strncmp(symname, CRC_PFX, strlen(CRC_PFX)) == 0) {
 621		crc = (unsigned int) sym->st_value;
 622		sym_update_crc(symname + strlen(CRC_PFX), mod, crc,
 623				export);
 624	}
 625
 626	switch (sym->st_shndx) {
 627	case SHN_COMMON:
 628		if (!strncmp(symname, "__gnu_lto_", sizeof("__gnu_lto_")-1)) {
 629			/* Should warn here, but modpost runs before the linker */
 630		} else
 631			warn("\"%s\" [%s] is COMMON symbol\n", symname, mod->name);
 632		break;
 633	case SHN_UNDEF:
 634		/* undefined symbol */
 635		if (ELF_ST_BIND(sym->st_info) != STB_GLOBAL &&
 636		    ELF_ST_BIND(sym->st_info) != STB_WEAK)
 637			break;
 638		if (ignore_undef_symbol(info, symname))
 639			break;
 640/* cope with newer glibc (2.3.4 or higher) STT_ definition in elf.h */
 641#if defined(STT_REGISTER) || defined(STT_SPARC_REGISTER)
 642/* add compatibility with older glibc */
 643#ifndef STT_SPARC_REGISTER
 644#define STT_SPARC_REGISTER STT_REGISTER
 645#endif
 646		if (info->hdr->e_machine == EM_SPARC ||
 647		    info->hdr->e_machine == EM_SPARCV9) {
 648			/* Ignore register directives. */
 649			if (ELF_ST_TYPE(sym->st_info) == STT_SPARC_REGISTER)
 650				break;
 651			if (symname[0] == '.') {
 652				char *munged = strdup(symname);
 653				munged[0] = '_';
 654				munged[1] = toupper(munged[1]);
 655				symname = munged;
 656			}
 657		}
 658#endif
 659
 660#ifdef CONFIG_HAVE_UNDERSCORE_SYMBOL_PREFIX
 661		if (symname[0] != '_')
 662			break;
 663		else
 664			symname++;
 665#endif
 666		mod->unres = alloc_symbol(symname,
 667					  ELF_ST_BIND(sym->st_info) == STB_WEAK,
 668					  mod->unres);
 669		break;
 670	default:
 671		/* All exported symbols */
 672		if (strncmp(symname, KSYMTAB_PFX, strlen(KSYMTAB_PFX)) == 0) {
 673			sym_add_exported(symname + strlen(KSYMTAB_PFX), mod,
 674					export);
 675		}
 676		if (strcmp(symname, VMLINUX_SYMBOL_STR(init_module)) == 0)
 677			mod->has_init = 1;
 678		if (strcmp(symname, VMLINUX_SYMBOL_STR(cleanup_module)) == 0)
 679			mod->has_cleanup = 1;
 680		break;
 681	}
 682}
 683
 684/**
 685 * Parse tag=value strings from .modinfo section
 686 **/
 687static char *next_string(char *string, unsigned long *secsize)
 688{
 689	/* Skip non-zero chars */
 690	while (string[0]) {
 691		string++;
 692		if ((*secsize)-- <= 1)
 693			return NULL;
 694	}
 695
 696	/* Skip any zero padding. */
 697	while (!string[0]) {
 698		string++;
 699		if ((*secsize)-- <= 1)
 700			return NULL;
 701	}
 702	return string;
 703}
 704
 705static char *get_next_modinfo(void *modinfo, unsigned long modinfo_len,
 706			      const char *tag, char *info)
 707{
 708	char *p;
 709	unsigned int taglen = strlen(tag);
 710	unsigned long size = modinfo_len;
 
 711
 712	if (info) {
 713		size -= info - (char *)modinfo;
 714		modinfo = next_string(info, &size);
 715	}
 716
 717	for (p = modinfo; p; p = next_string(p, &size)) {
 718		if (strncmp(p, tag, taglen) == 0 && p[taglen] == '=')
 719			return p + taglen + 1;
 720	}
 721	return NULL;
 722}
 723
 724static char *get_modinfo(void *modinfo, unsigned long modinfo_len,
 725			 const char *tag)
 726
 727{
 728	return get_next_modinfo(modinfo, modinfo_len, tag, NULL);
 729}
 730
 731/**
 732 * Test if string s ends in string sub
 733 * return 0 if match
 734 **/
 735static int strrcmp(const char *s, const char *sub)
 736{
 737	int slen, sublen;
 738
 739	if (!s || !sub)
 740		return 1;
 741
 742	slen = strlen(s);
 743	sublen = strlen(sub);
 744
 745	if ((slen == 0) || (sublen == 0))
 746		return 1;
 747
 748	if (sublen > slen)
 749		return 1;
 750
 751	return memcmp(s + slen - sublen, sub, sublen);
 752}
 753
 754static const char *sym_name(struct elf_info *elf, Elf_Sym *sym)
 755{
 756	if (sym)
 757		return elf->strtab + sym->st_name;
 758	else
 759		return "(unknown)";
 760}
 761
 762static const char *sec_name(struct elf_info *elf, int secindex)
 763{
 764	Elf_Shdr *sechdrs = elf->sechdrs;
 765	return (void *)elf->hdr +
 766		elf->sechdrs[elf->secindex_strings].sh_offset +
 767		sechdrs[secindex].sh_name;
 768}
 769
 770static const char *sech_name(struct elf_info *elf, Elf_Shdr *sechdr)
 771{
 772	return (void *)elf->hdr +
 773		elf->sechdrs[elf->secindex_strings].sh_offset +
 774		sechdr->sh_name;
 775}
 776
 777/* The pattern is an array of simple patterns.
 778 * "foo" will match an exact string equal to "foo"
 779 * "*foo" will match a string that ends with "foo"
 780 * "foo*" will match a string that begins with "foo"
 781 * "*foo*" will match a string that contains "foo"
 782 */
 783static int match(const char *sym, const char * const pat[])
 784{
 785	const char *p;
 786	while (*pat) {
 787		p = *pat++;
 788		const char *endp = p + strlen(p) - 1;
 789
 790		/* "*foo*" */
 791		if (*p == '*' && *endp == '*') {
 792			char *here, *bare = strndup(p + 1, strlen(p) - 2);
 793
 794			here = strstr(sym, bare);
 795			free(bare);
 796			if (here != NULL)
 797				return 1;
 798		}
 799		/* "*foo" */
 800		else if (*p == '*') {
 801			if (strrcmp(sym, p + 1) == 0)
 802				return 1;
 803		}
 804		/* "foo*" */
 805		else if (*endp == '*') {
 806			if (strncmp(sym, p, strlen(p) - 1) == 0)
 807				return 1;
 808		}
 809		/* no wildcards */
 810		else {
 811			if (strcmp(p, sym) == 0)
 812				return 1;
 813		}
 814	}
 815	/* no match */
 816	return 0;
 817}
 818
 
 
 
 
 
 
 
 819/* sections that we do not want to do full section mismatch check on */
 820static const char *const section_white_list[] =
 821{
 822	".comment*",
 823	".debug*",
 824	".cranges",		/* sh64 */
 825	".zdebug*",		/* Compressed debug sections. */
 826	".GCC-command-line",	/* mn10300 */
 827	".GCC.command.line",	/* record-gcc-switches, non mn10300 */
 828	".mdebug*",        /* alpha, score, mips etc. */
 829	".pdr",            /* alpha, score, mips etc. */
 830	".stab*",
 831	".note*",
 832	".got*",
 833	".toc*",
 834	".xt.prop",				 /* xtensa */
 835	".xt.lit",         /* xtensa */
 836	".arcextmap*",			/* arc */
 837	".gnu.linkonce.arcext*",	/* arc : modules */
 838	".cmem*",			/* EZchip */
 839	".fmt_slot*",			/* EZchip */
 840	".gnu.lto*",
 
 
 841	NULL
 842};
 843
 844/*
 845 * This is used to find sections missing the SHF_ALLOC flag.
 846 * The cause of this is often a section specified in assembler
 847 * without "ax" / "aw".
 848 */
 849static void check_section(const char *modname, struct elf_info *elf,
 850			  Elf_Shdr *sechdr)
 851{
 852	const char *sec = sech_name(elf, sechdr);
 853
 854	if (sechdr->sh_type == SHT_PROGBITS &&
 855	    !(sechdr->sh_flags & SHF_ALLOC) &&
 856	    !match(sec, section_white_list)) {
 857		warn("%s (%s): unexpected non-allocatable section.\n"
 858		     "Did you forget to use \"ax\"/\"aw\" in a .S file?\n"
 859		     "Note that for example <linux/init.h> contains\n"
 860		     "section definitions for use in .S files.\n\n",
 861		     modname, sec);
 862	}
 863}
 864
 865
 866
 867#define ALL_INIT_DATA_SECTIONS \
 868	".init.setup", ".init.rodata", ".meminit.rodata", \
 869	".init.data", ".meminit.data"
 870#define ALL_EXIT_DATA_SECTIONS \
 871	".exit.data", ".memexit.data"
 872
 873#define ALL_INIT_TEXT_SECTIONS \
 874	".init.text", ".meminit.text"
 875#define ALL_EXIT_TEXT_SECTIONS \
 876	".exit.text", ".memexit.text"
 877
 878#define ALL_PCI_INIT_SECTIONS	\
 879	".pci_fixup_early", ".pci_fixup_header", ".pci_fixup_final", \
 880	".pci_fixup_enable", ".pci_fixup_resume", \
 881	".pci_fixup_resume_early", ".pci_fixup_suspend"
 882
 883#define ALL_XXXINIT_SECTIONS MEM_INIT_SECTIONS
 884#define ALL_XXXEXIT_SECTIONS MEM_EXIT_SECTIONS
 885
 886#define ALL_INIT_SECTIONS INIT_SECTIONS, ALL_XXXINIT_SECTIONS
 887#define ALL_EXIT_SECTIONS EXIT_SECTIONS, ALL_XXXEXIT_SECTIONS
 888
 889#define DATA_SECTIONS ".data", ".data.rel"
 890#define TEXT_SECTIONS ".text", ".text.unlikely", ".sched.text", \
 891		".kprobes.text"
 
 892#define OTHER_TEXT_SECTIONS ".ref.text", ".head.text", ".spinlock.text", \
 893		".fixup", ".entry.text", ".exception.text", ".text.*", \
 894		".coldtext"
 895
 896#define INIT_SECTIONS      ".init.*"
 897#define MEM_INIT_SECTIONS  ".meminit.*"
 898
 899#define EXIT_SECTIONS      ".exit.*"
 900#define MEM_EXIT_SECTIONS  ".memexit.*"
 901
 902#define ALL_TEXT_SECTIONS  ALL_INIT_TEXT_SECTIONS, ALL_EXIT_TEXT_SECTIONS, \
 903		TEXT_SECTIONS, OTHER_TEXT_SECTIONS
 904
 905/* init data sections */
 906static const char *const init_data_sections[] =
 907	{ ALL_INIT_DATA_SECTIONS, NULL };
 908
 909/* all init sections */
 910static const char *const init_sections[] = { ALL_INIT_SECTIONS, NULL };
 911
 912/* All init and exit sections (code + data) */
 913static const char *const init_exit_sections[] =
 914	{ALL_INIT_SECTIONS, ALL_EXIT_SECTIONS, NULL };
 915
 916/* all text sections */
 917static const char *const text_sections[] = { ALL_TEXT_SECTIONS, NULL };
 918
 919/* data section */
 920static const char *const data_sections[] = { DATA_SECTIONS, NULL };
 921
 922
 923/* symbols in .data that may refer to init/exit sections */
 924#define DEFAULT_SYMBOL_WHITE_LIST					\
 925	"*driver",							\
 926	"*_template", /* scsi uses *_template a lot */			\
 927	"*_timer",    /* arm uses ops structures named _timer a lot */	\
 928	"*_sht",      /* scsi also used *_sht to some extent */		\
 929	"*_ops",							\
 930	"*_probe",							\
 931	"*_probe_one",							\
 932	"*_console"
 933
 934static const char *const head_sections[] = { ".head.text*", NULL };
 935static const char *const linker_symbols[] =
 936	{ "__init_begin", "_sinittext", "_einittext", NULL };
 937static const char *const optim_symbols[] = { "*.constprop.*", NULL };
 938
 939enum mismatch {
 940	TEXT_TO_ANY_INIT,
 941	DATA_TO_ANY_INIT,
 942	TEXT_TO_ANY_EXIT,
 943	DATA_TO_ANY_EXIT,
 944	XXXINIT_TO_SOME_INIT,
 945	XXXEXIT_TO_SOME_EXIT,
 946	ANY_INIT_TO_ANY_EXIT,
 947	ANY_EXIT_TO_ANY_INIT,
 948	EXPORT_TO_INIT_EXIT,
 949	EXTABLE_TO_NON_TEXT,
 950};
 951
 952/**
 953 * Describe how to match sections on different criterias:
 954 *
 955 * @fromsec: Array of sections to be matched.
 956 *
 957 * @bad_tosec: Relocations applied to a section in @fromsec to a section in
 958 * this array is forbidden (black-list).  Can be empty.
 959 *
 960 * @good_tosec: Relocations applied to a section in @fromsec must be
 961 * targetting sections in this array (white-list).  Can be empty.
 962 *
 963 * @mismatch: Type of mismatch.
 964 *
 965 * @symbol_white_list: Do not match a relocation to a symbol in this list
 966 * even if it is targetting a section in @bad_to_sec.
 967 *
 968 * @handler: Specific handler to call when a match is found.  If NULL,
 969 * default_mismatch_handler() will be called.
 970 *
 971 */
 972struct sectioncheck {
 973	const char *fromsec[20];
 974	const char *bad_tosec[20];
 975	const char *good_tosec[20];
 976	enum mismatch mismatch;
 977	const char *symbol_white_list[20];
 978	void (*handler)(const char *modname, struct elf_info *elf,
 979			const struct sectioncheck* const mismatch,
 980			Elf_Rela *r, Elf_Sym *sym, const char *fromsec);
 981
 982};
 983
 984static void extable_mismatch_handler(const char *modname, struct elf_info *elf,
 985				     const struct sectioncheck* const mismatch,
 986				     Elf_Rela *r, Elf_Sym *sym,
 987				     const char *fromsec);
 988
 989static const struct sectioncheck sectioncheck[] = {
 990/* Do not reference init/exit code/data from
 991 * normal code and data
 992 */
 993{
 994	.fromsec = { TEXT_SECTIONS, NULL },
 995	.bad_tosec = { ALL_INIT_SECTIONS, NULL },
 996	.mismatch = TEXT_TO_ANY_INIT,
 997	.symbol_white_list = { DEFAULT_SYMBOL_WHITE_LIST, NULL },
 998},
 999{
1000	.fromsec = { DATA_SECTIONS, NULL },
1001	.bad_tosec = { ALL_XXXINIT_SECTIONS, NULL },
1002	.mismatch = DATA_TO_ANY_INIT,
1003	.symbol_white_list = { DEFAULT_SYMBOL_WHITE_LIST, NULL },
1004},
1005{
1006	.fromsec = { DATA_SECTIONS, NULL },
1007	.bad_tosec = { INIT_SECTIONS, NULL },
1008	.mismatch = DATA_TO_ANY_INIT,
1009	.symbol_white_list = {
1010		"*_template", "*_timer", "*_sht", "*_ops",
1011		"*_probe", "*_probe_one", "*_console", NULL
1012	},
1013},
1014{
1015	.fromsec = { TEXT_SECTIONS, NULL },
1016	.bad_tosec = { ALL_EXIT_SECTIONS, NULL },
1017	.mismatch = TEXT_TO_ANY_EXIT,
1018	.symbol_white_list = { DEFAULT_SYMBOL_WHITE_LIST, NULL },
1019},
1020{
1021	.fromsec = { DATA_SECTIONS, NULL },
1022	.bad_tosec = { ALL_EXIT_SECTIONS, NULL },
1023	.mismatch = DATA_TO_ANY_EXIT,
1024	.symbol_white_list = { DEFAULT_SYMBOL_WHITE_LIST, NULL },
1025},
1026/* Do not reference init code/data from meminit code/data */
1027{
1028	.fromsec = { ALL_XXXINIT_SECTIONS, NULL },
1029	.bad_tosec = { INIT_SECTIONS, NULL },
1030	.mismatch = XXXINIT_TO_SOME_INIT,
1031	.symbol_white_list = { DEFAULT_SYMBOL_WHITE_LIST, NULL },
1032},
1033/* Do not reference exit code/data from memexit code/data */
1034{
1035	.fromsec = { ALL_XXXEXIT_SECTIONS, NULL },
1036	.bad_tosec = { EXIT_SECTIONS, NULL },
1037	.mismatch = XXXEXIT_TO_SOME_EXIT,
1038	.symbol_white_list = { DEFAULT_SYMBOL_WHITE_LIST, NULL },
1039},
1040/* Do not use exit code/data from init code */
1041{
1042	.fromsec = { ALL_INIT_SECTIONS, NULL },
1043	.bad_tosec = { ALL_EXIT_SECTIONS, NULL },
1044	.mismatch = ANY_INIT_TO_ANY_EXIT,
1045	.symbol_white_list = { DEFAULT_SYMBOL_WHITE_LIST, NULL },
1046},
1047/* Do not use init code/data from exit code */
1048{
1049	.fromsec = { ALL_EXIT_SECTIONS, NULL },
1050	.bad_tosec = { ALL_INIT_SECTIONS, NULL },
1051	.mismatch = ANY_EXIT_TO_ANY_INIT,
1052	.symbol_white_list = { DEFAULT_SYMBOL_WHITE_LIST, NULL },
1053},
1054{
1055	.fromsec = { ALL_PCI_INIT_SECTIONS, NULL },
1056	.bad_tosec = { INIT_SECTIONS, NULL },
1057	.mismatch = ANY_INIT_TO_ANY_EXIT,
1058	.symbol_white_list = { NULL },
1059},
1060/* Do not export init/exit functions or data */
1061{
1062	.fromsec = { "__ksymtab*", NULL },
1063	.bad_tosec = { INIT_SECTIONS, EXIT_SECTIONS, NULL },
1064	.mismatch = EXPORT_TO_INIT_EXIT,
1065	.symbol_white_list = { DEFAULT_SYMBOL_WHITE_LIST, NULL },
1066},
1067{
1068	.fromsec = { "__ex_table", NULL },
1069	/* If you're adding any new black-listed sections in here, consider
1070	 * adding a special 'printer' for them in scripts/check_extable.
1071	 */
1072	.bad_tosec = { ".altinstr_replacement", NULL },
1073	.good_tosec = {ALL_TEXT_SECTIONS , NULL},
1074	.mismatch = EXTABLE_TO_NON_TEXT,
1075	.handler = extable_mismatch_handler,
1076}
1077};
1078
1079static const struct sectioncheck *section_mismatch(
1080		const char *fromsec, const char *tosec)
1081{
1082	int i;
1083	int elems = sizeof(sectioncheck) / sizeof(struct sectioncheck);
1084	const struct sectioncheck *check = &sectioncheck[0];
1085
1086	/*
1087	 * The target section could be the SHT_NUL section when we're
1088	 * handling relocations to un-resolved symbols, trying to match it
1089	 * doesn't make much sense and causes build failures on parisc and
1090	 * mn10300 architectures.
1091	 */
1092	if (*tosec == '\0')
1093		return NULL;
1094
1095	for (i = 0; i < elems; i++) {
 
 
1096		if (match(fromsec, check->fromsec)) {
1097			if (check->bad_tosec[0] && match(tosec, check->bad_tosec))
1098				return check;
1099			if (check->good_tosec[0] && !match(tosec, check->good_tosec))
1100				return check;
1101		}
1102		check++;
1103	}
1104	return NULL;
1105}
1106
1107/**
1108 * Whitelist to allow certain references to pass with no warning.
1109 *
1110 * Pattern 1:
1111 *   If a module parameter is declared __initdata and permissions=0
1112 *   then this is legal despite the warning generated.
1113 *   We cannot see value of permissions here, so just ignore
1114 *   this pattern.
1115 *   The pattern is identified by:
1116 *   tosec   = .init.data
1117 *   fromsec = .data*
1118 *   atsym   =__param*
1119 *
1120 * Pattern 1a:
1121 *   module_param_call() ops can refer to __init set function if permissions=0
1122 *   The pattern is identified by:
1123 *   tosec   = .init.text
1124 *   fromsec = .data*
1125 *   atsym   = __param_ops_*
1126 *
1127 * Pattern 2:
1128 *   Many drivers utilise a *driver container with references to
1129 *   add, remove, probe functions etc.
1130 *   the pattern is identified by:
1131 *   tosec   = init or exit section
1132 *   fromsec = data section
1133 *   atsym = *driver, *_template, *_sht, *_ops, *_probe,
1134 *           *probe_one, *_console, *_timer
1135 *
1136 * Pattern 3:
1137 *   Whitelist all references from .head.text to any init section
1138 *
1139 * Pattern 4:
1140 *   Some symbols belong to init section but still it is ok to reference
1141 *   these from non-init sections as these symbols don't have any memory
1142 *   allocated for them and symbol address and value are same. So even
1143 *   if init section is freed, its ok to reference those symbols.
1144 *   For ex. symbols marking the init section boundaries.
1145 *   This pattern is identified by
1146 *   refsymname = __init_begin, _sinittext, _einittext
1147 *
1148 * Pattern 5:
1149 *   GCC may optimize static inlines when fed constant arg(s) resulting
1150 *   in functions like cpumask_empty() -- generating an associated symbol
1151 *   cpumask_empty.constprop.3 that appears in the audit.  If the const that
1152 *   is passed in comes from __init, like say nmi_ipi_mask, we get a
1153 *   meaningless section warning.  May need to add isra symbols too...
1154 *   This pattern is identified by
1155 *   tosec   = init section
1156 *   fromsec = text section
1157 *   refsymname = *.constprop.*
1158 *
1159 **/
1160static int secref_whitelist(const struct sectioncheck *mismatch,
1161			    const char *fromsec, const char *fromsym,
1162			    const char *tosec, const char *tosym)
1163{
1164	/* Check for pattern 1 */
1165	if (match(tosec, init_data_sections) &&
1166	    match(fromsec, data_sections) &&
1167	    (strncmp(fromsym, "__param", strlen("__param")) == 0))
1168		return 0;
1169
1170	/* Check for pattern 1a */
1171	if (strcmp(tosec, ".init.text") == 0 &&
1172	    match(fromsec, data_sections) &&
1173	    (strncmp(fromsym, "__param_ops_", strlen("__param_ops_")) == 0))
1174		return 0;
1175
1176	/* Check for pattern 2 */
1177	if (match(tosec, init_exit_sections) &&
1178	    match(fromsec, data_sections) &&
1179	    match(fromsym, mismatch->symbol_white_list))
1180		return 0;
1181
1182	/* Check for pattern 3 */
1183	if (match(fromsec, head_sections) &&
1184	    match(tosec, init_sections))
1185		return 0;
1186
1187	/* Check for pattern 4 */
1188	if (match(tosym, linker_symbols))
1189		return 0;
1190
1191	/* Check for pattern 5 */
1192	if (match(fromsec, text_sections) &&
1193	    match(tosec, init_sections) &&
1194	    match(fromsym, optim_symbols))
1195		return 0;
1196
1197	return 1;
1198}
1199
1200/**
1201 * Find symbol based on relocation record info.
1202 * In some cases the symbol supplied is a valid symbol so
1203 * return refsym. If st_name != 0 we assume this is a valid symbol.
1204 * In other cases the symbol needs to be looked up in the symbol table
1205 * based on section and address.
1206 *  **/
1207static Elf_Sym *find_elf_symbol(struct elf_info *elf, Elf64_Sword addr,
1208				Elf_Sym *relsym)
1209{
1210	Elf_Sym *sym;
1211	Elf_Sym *near = NULL;
1212	Elf64_Sword distance = 20;
1213	Elf64_Sword d;
1214	unsigned int relsym_secindex;
1215
1216	if (relsym->st_name != 0)
1217		return relsym;
1218
1219	relsym_secindex = get_secindex(elf, relsym);
1220	for (sym = elf->symtab_start; sym < elf->symtab_stop; sym++) {
1221		if (get_secindex(elf, sym) != relsym_secindex)
1222			continue;
1223		if (ELF_ST_TYPE(sym->st_info) == STT_SECTION)
1224			continue;
1225		if (sym->st_value == addr)
1226			return sym;
1227		/* Find a symbol nearby - addr are maybe negative */
1228		d = sym->st_value - addr;
1229		if (d < 0)
1230			d = addr - sym->st_value;
1231		if (d < distance) {
1232			distance = d;
1233			near = sym;
1234		}
1235	}
1236	/* We need a close match */
1237	if (distance < 20)
1238		return near;
1239	else
1240		return NULL;
1241}
1242
1243static inline int is_arm_mapping_symbol(const char *str)
1244{
1245	return str[0] == '$' && strchr("axtd", str[1])
1246	       && (str[2] == '\0' || str[2] == '.');
1247}
1248
1249/*
1250 * If there's no name there, ignore it; likewise, ignore it if it's
1251 * one of the magic symbols emitted used by current ARM tools.
1252 *
1253 * Otherwise if find_symbols_between() returns those symbols, they'll
1254 * fail the whitelist tests and cause lots of false alarms ... fixable
1255 * only by merging __exit and __init sections into __text, bloating
1256 * the kernel (which is especially evil on embedded platforms).
1257 */
1258static inline int is_valid_name(struct elf_info *elf, Elf_Sym *sym)
1259{
1260	const char *name = elf->strtab + sym->st_name;
1261
1262	if (!name || !strlen(name))
1263		return 0;
1264	return !is_arm_mapping_symbol(name);
 
 
 
 
1265}
1266
1267/*
1268 * Find symbols before or equal addr and after addr - in the section sec.
1269 * If we find two symbols with equal offset prefer one with a valid name.
1270 * The ELF format may have a better way to detect what type of symbol
1271 * it is, but this works for now.
1272 **/
1273static Elf_Sym *find_elf_symbol2(struct elf_info *elf, Elf_Addr addr,
1274				 const char *sec)
1275{
1276	Elf_Sym *sym;
1277	Elf_Sym *near = NULL;
1278	Elf_Addr distance = ~0;
1279
1280	for (sym = elf->symtab_start; sym < elf->symtab_stop; sym++) {
1281		const char *symsec;
1282
1283		if (is_shndx_special(sym->st_shndx))
1284			continue;
1285		symsec = sec_name(elf, get_secindex(elf, sym));
1286		if (strcmp(symsec, sec) != 0)
1287			continue;
1288		if (!is_valid_name(elf, sym))
1289			continue;
1290		if (sym->st_value <= addr) {
1291			if ((addr - sym->st_value) < distance) {
1292				distance = addr - sym->st_value;
1293				near = sym;
1294			} else if ((addr - sym->st_value) == distance) {
1295				near = sym;
1296			}
1297		}
1298	}
1299	return near;
1300}
1301
1302/*
1303 * Convert a section name to the function/data attribute
1304 * .init.text => __init
1305 * .memexitconst => __memconst
1306 * etc.
1307 *
1308 * The memory of returned value has been allocated on a heap. The user of this
1309 * method should free it after usage.
1310*/
1311static char *sec2annotation(const char *s)
1312{
1313	if (match(s, init_exit_sections)) {
1314		char *p = malloc(20);
1315		char *r = p;
1316
1317		*p++ = '_';
1318		*p++ = '_';
1319		if (*s == '.')
1320			s++;
1321		while (*s && *s != '.')
1322			*p++ = *s++;
1323		*p = '\0';
1324		if (*s == '.')
1325			s++;
1326		if (strstr(s, "rodata") != NULL)
1327			strcat(p, "const ");
1328		else if (strstr(s, "data") != NULL)
1329			strcat(p, "data ");
1330		else
1331			strcat(p, " ");
1332		return r;
1333	} else {
1334		return strdup("");
1335	}
1336}
1337
1338static int is_function(Elf_Sym *sym)
1339{
1340	if (sym)
1341		return ELF_ST_TYPE(sym->st_info) == STT_FUNC;
1342	else
1343		return -1;
1344}
1345
1346static void print_section_list(const char * const list[20])
 
 
 
 
1347{
1348	const char *const *s = list;
 
 
 
1349
1350	while (*s) {
1351		fprintf(stderr, "%s", *s);
1352		s++;
1353		if (*s)
1354			fprintf(stderr, ", ");
1355	}
1356	fprintf(stderr, "\n");
1357}
1358
1359static inline void get_pretty_name(int is_func, const char** name, const char** name_p)
1360{
1361	switch (is_func) {
1362	case 0:	*name = "variable"; *name_p = ""; break;
1363	case 1:	*name = "function"; *name_p = "()"; break;
1364	default: *name = "(unknown reference)"; *name_p = ""; break;
1365	}
1366}
1367
1368/*
1369 * Print a warning about a section mismatch.
1370 * Try to find symbols near it so user can find it.
1371 * Check whitelist before warning - it may be a false positive.
1372 */
1373static void report_sec_mismatch(const char *modname,
1374				const struct sectioncheck *mismatch,
1375				const char *fromsec,
1376				unsigned long long fromaddr,
1377				const char *fromsym,
1378				int from_is_func,
1379				const char *tosec, const char *tosym,
1380				int to_is_func)
1381{
1382	const char *from, *from_p;
1383	const char *to, *to_p;
1384	char *prl_from;
1385	char *prl_to;
1386
1387	sec_mismatch_count++;
1388	if (!sec_mismatch_verbose)
1389		return;
1390
1391	get_pretty_name(from_is_func, &from, &from_p);
1392	get_pretty_name(to_is_func, &to, &to_p);
1393
1394	warn("%s(%s+0x%llx): Section mismatch in reference from the %s %s%s "
1395	     "to the %s %s:%s%s\n",
1396	     modname, fromsec, fromaddr, from, fromsym, from_p, to, tosec,
1397	     tosym, to_p);
1398
1399	switch (mismatch->mismatch) {
1400	case TEXT_TO_ANY_INIT:
1401		prl_from = sec2annotation(fromsec);
1402		prl_to = sec2annotation(tosec);
1403		fprintf(stderr,
1404		"The function %s%s() references\n"
1405		"the %s %s%s%s.\n"
1406		"This is often because %s lacks a %s\n"
1407		"annotation or the annotation of %s is wrong.\n",
1408		prl_from, fromsym,
1409		to, prl_to, tosym, to_p,
1410		fromsym, prl_to, tosym);
1411		free(prl_from);
1412		free(prl_to);
1413		break;
1414	case DATA_TO_ANY_INIT: {
1415		prl_to = sec2annotation(tosec);
1416		fprintf(stderr,
1417		"The variable %s references\n"
1418		"the %s %s%s%s\n"
1419		"If the reference is valid then annotate the\n"
1420		"variable with __init* or __refdata (see linux/init.h) "
1421		"or name the variable:\n",
1422		fromsym, to, prl_to, tosym, to_p);
1423		print_section_list(mismatch->symbol_white_list);
1424		free(prl_to);
1425		break;
1426	}
1427	case TEXT_TO_ANY_EXIT:
1428		prl_to = sec2annotation(tosec);
1429		fprintf(stderr,
1430		"The function %s() references a %s in an exit section.\n"
1431		"Often the %s %s%s has valid usage outside the exit section\n"
1432		"and the fix is to remove the %sannotation of %s.\n",
1433		fromsym, to, to, tosym, to_p, prl_to, tosym);
1434		free(prl_to);
1435		break;
1436	case DATA_TO_ANY_EXIT: {
1437		prl_to = sec2annotation(tosec);
1438		fprintf(stderr,
1439		"The variable %s references\n"
1440		"the %s %s%s%s\n"
1441		"If the reference is valid then annotate the\n"
1442		"variable with __exit* (see linux/init.h) or "
1443		"name the variable:\n",
1444		fromsym, to, prl_to, tosym, to_p);
1445		print_section_list(mismatch->symbol_white_list);
1446		free(prl_to);
1447		break;
1448	}
1449	case XXXINIT_TO_SOME_INIT:
1450	case XXXEXIT_TO_SOME_EXIT:
1451		prl_from = sec2annotation(fromsec);
1452		prl_to = sec2annotation(tosec);
1453		fprintf(stderr,
1454		"The %s %s%s%s references\n"
1455		"a %s %s%s%s.\n"
1456		"If %s is only used by %s then\n"
1457		"annotate %s with a matching annotation.\n",
1458		from, prl_from, fromsym, from_p,
1459		to, prl_to, tosym, to_p,
1460		tosym, fromsym, tosym);
1461		free(prl_from);
1462		free(prl_to);
1463		break;
1464	case ANY_INIT_TO_ANY_EXIT:
1465		prl_from = sec2annotation(fromsec);
1466		prl_to = sec2annotation(tosec);
1467		fprintf(stderr,
1468		"The %s %s%s%s references\n"
1469		"a %s %s%s%s.\n"
1470		"This is often seen when error handling "
1471		"in the init function\n"
1472		"uses functionality in the exit path.\n"
1473		"The fix is often to remove the %sannotation of\n"
1474		"%s%s so it may be used outside an exit section.\n",
1475		from, prl_from, fromsym, from_p,
1476		to, prl_to, tosym, to_p,
1477		prl_to, tosym, to_p);
1478		free(prl_from);
1479		free(prl_to);
1480		break;
1481	case ANY_EXIT_TO_ANY_INIT:
1482		prl_from = sec2annotation(fromsec);
1483		prl_to = sec2annotation(tosec);
1484		fprintf(stderr,
1485		"The %s %s%s%s references\n"
1486		"a %s %s%s%s.\n"
1487		"This is often seen when error handling "
1488		"in the exit function\n"
1489		"uses functionality in the init path.\n"
1490		"The fix is often to remove the %sannotation of\n"
1491		"%s%s so it may be used outside an init section.\n",
1492		from, prl_from, fromsym, from_p,
1493		to, prl_to, tosym, to_p,
1494		prl_to, tosym, to_p);
1495		free(prl_from);
1496		free(prl_to);
1497		break;
1498	case EXPORT_TO_INIT_EXIT:
1499		prl_to = sec2annotation(tosec);
1500		fprintf(stderr,
1501		"The symbol %s is exported and annotated %s\n"
1502		"Fix this by removing the %sannotation of %s "
1503		"or drop the export.\n",
1504		tosym, prl_to, prl_to, tosym);
1505		free(prl_to);
1506		break;
1507	case EXTABLE_TO_NON_TEXT:
1508		fatal("There's a special handler for this mismatch type, "
1509		      "we should never get here.");
1510		break;
1511	}
1512	fprintf(stderr, "\n");
1513}
1514
1515static void default_mismatch_handler(const char *modname, struct elf_info *elf,
1516				     const struct sectioncheck* const mismatch,
1517				     Elf_Rela *r, Elf_Sym *sym, const char *fromsec)
1518{
1519	const char *tosec;
1520	Elf_Sym *to;
1521	Elf_Sym *from;
1522	const char *tosym;
1523	const char *fromsym;
1524
1525	from = find_elf_symbol2(elf, r->r_offset, fromsec);
1526	fromsym = sym_name(elf, from);
1527
1528	if (!strncmp(fromsym, "reference___initcall",
1529		     sizeof("reference___initcall")-1))
 
1530		return;
 
1531
1532	tosec = sec_name(elf, get_secindex(elf, sym));
1533	to = find_elf_symbol(elf, r->r_addend, sym);
1534	tosym = sym_name(elf, to);
 
 
 
1535
1536	/* check whitelist - we may ignore it */
1537	if (secref_whitelist(mismatch,
1538			     fromsec, fromsym, tosec, tosym)) {
1539		report_sec_mismatch(modname, mismatch,
1540				    fromsec, r->r_offset, fromsym,
1541				    is_function(from), tosec, tosym,
1542				    is_function(to));
1543	}
1544}
1545
1546static int is_executable_section(struct elf_info* elf, unsigned int section_index)
1547{
1548	if (section_index > elf->num_sections)
1549		fatal("section_index is outside elf->num_sections!\n");
 
 
 
 
 
 
1550
1551	return ((elf->sechdrs[section_index].sh_flags & SHF_EXECINSTR) == SHF_EXECINSTR);
1552}
1553
1554/*
1555 * We rely on a gross hack in section_rel[a]() calling find_extable_entry_size()
1556 * to know the sizeof(struct exception_table_entry) for the target architecture.
1557 */
1558static unsigned int extable_entry_size = 0;
1559static void find_extable_entry_size(const char* const sec, const Elf_Rela* r)
1560{
1561	/*
1562	 * If we're currently checking the second relocation within __ex_table,
1563	 * that relocation offset tells us the offsetof(struct
1564	 * exception_table_entry, fixup) which is equal to sizeof(struct
1565	 * exception_table_entry) divided by two.  We use that to our advantage
1566	 * since there's no portable way to get that size as every architecture
1567	 * seems to go with different sized types.  Not pretty but better than
1568	 * hard-coding the size for every architecture..
1569	 */
1570	if (!extable_entry_size)
1571		extable_entry_size = r->r_offset * 2;
1572}
1573
1574static inline bool is_extable_fault_address(Elf_Rela *r)
1575{
1576	/*
1577	 * extable_entry_size is only discovered after we've handled the
1578	 * _second_ relocation in __ex_table, so only abort when we're not
1579	 * handling the first reloc and extable_entry_size is zero.
1580	 */
1581	if (r->r_offset && extable_entry_size == 0)
1582		fatal("extable_entry size hasn't been discovered!\n");
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1583
1584	return ((r->r_offset == 0) ||
1585		(r->r_offset % extable_entry_size == 0));
1586}
 
 
 
 
 
1587
1588#define is_second_extable_reloc(Start, Cur, Sec)			\
1589	(((Cur) == (Start) + 1) && (strcmp("__ex_table", (Sec)) == 0))
1590
1591static void report_extable_warnings(const char* modname, struct elf_info* elf,
1592				    const struct sectioncheck* const mismatch,
1593				    Elf_Rela* r, Elf_Sym* sym,
1594				    const char* fromsec, const char* tosec)
1595{
1596	Elf_Sym* fromsym = find_elf_symbol2(elf, r->r_offset, fromsec);
1597	const char* fromsym_name = sym_name(elf, fromsym);
1598	Elf_Sym* tosym = find_elf_symbol(elf, r->r_addend, sym);
1599	const char* tosym_name = sym_name(elf, tosym);
1600	const char* from_pretty_name;
1601	const char* from_pretty_name_p;
1602	const char* to_pretty_name;
1603	const char* to_pretty_name_p;
1604
1605	get_pretty_name(is_function(fromsym),
1606			&from_pretty_name, &from_pretty_name_p);
1607	get_pretty_name(is_function(tosym),
1608			&to_pretty_name, &to_pretty_name_p);
1609
1610	warn("%s(%s+0x%lx): Section mismatch in reference"
1611	     " from the %s %s%s to the %s %s:%s%s\n",
1612	     modname, fromsec, (long)r->r_offset, from_pretty_name,
1613	     fromsym_name, from_pretty_name_p,
1614	     to_pretty_name, tosec, tosym_name, to_pretty_name_p);
1615
1616	if (!match(tosec, mismatch->bad_tosec) &&
1617	    is_executable_section(elf, get_secindex(elf, sym)))
1618		fprintf(stderr,
1619			"The relocation at %s+0x%lx references\n"
1620			"section \"%s\" which is not in the list of\n"
1621			"authorized sections.  If you're adding a new section\n"
1622			"and/or if this reference is valid, add \"%s\" to the\n"
1623			"list of authorized sections to jump to on fault.\n"
1624			"This can be achieved by adding \"%s\" to \n"
1625			"OTHER_TEXT_SECTIONS in scripts/mod/modpost.c.\n",
1626			fromsec, (long)r->r_offset, tosec, tosec, tosec);
1627}
1628
1629static void extable_mismatch_handler(const char* modname, struct elf_info *elf,
1630				     const struct sectioncheck* const mismatch,
1631				     Elf_Rela* r, Elf_Sym* sym,
1632				     const char *fromsec)
1633{
1634	const char* tosec = sec_name(elf, get_secindex(elf, sym));
1635
1636	sec_mismatch_count++;
1637
1638	if (sec_mismatch_verbose)
1639		report_extable_warnings(modname, elf, mismatch, r, sym,
1640					fromsec, tosec);
1641
1642	if (match(tosec, mismatch->bad_tosec))
1643		fatal("The relocation at %s+0x%lx references\n"
1644		      "section \"%s\" which is black-listed.\n"
1645		      "Something is seriously wrong and should be fixed.\n"
1646		      "You might get more information about where this is\n"
1647		      "coming from by using scripts/check_extable.sh %s\n",
1648		      fromsec, (long)r->r_offset, tosec, modname);
1649	else if (!is_executable_section(elf, get_secindex(elf, sym))) {
1650		if (is_extable_fault_address(r))
1651			fatal("The relocation at %s+0x%lx references\n"
1652			      "section \"%s\" which is not executable, IOW\n"
1653			      "it is not possible for the kernel to fault\n"
1654			      "at that address.  Something is seriously wrong\n"
1655			      "and should be fixed.\n",
1656			      fromsec, (long)r->r_offset, tosec);
1657		else
1658			fatal("The relocation at %s+0x%lx references\n"
1659			      "section \"%s\" which is not executable, IOW\n"
1660			      "the kernel will fault if it ever tries to\n"
1661			      "jump to it.  Something is seriously wrong\n"
1662			      "and should be fixed.\n",
1663			      fromsec, (long)r->r_offset, tosec);
1664	}
 
 
1665}
1666
1667static void check_section_mismatch(const char *modname, struct elf_info *elf,
1668				   Elf_Rela *r, Elf_Sym *sym, const char *fromsec)
1669{
1670	const char *tosec = sec_name(elf, get_secindex(elf, sym));;
1671	const struct sectioncheck *mismatch = section_mismatch(fromsec, tosec);
1672
1673	if (mismatch) {
1674		if (mismatch->handler)
1675			mismatch->handler(modname, elf,  mismatch,
1676					  r, sym, fromsec);
1677		else
1678			default_mismatch_handler(modname, elf, mismatch,
1679						 r, sym, fromsec);
1680	}
1681}
1682
1683static unsigned int *reloc_location(struct elf_info *elf,
1684				    Elf_Shdr *sechdr, Elf_Rela *r)
1685{
1686	Elf_Shdr *sechdrs = elf->sechdrs;
1687	int section = sechdr->sh_info;
1688
1689	return (void *)elf->hdr + sechdrs[section].sh_offset +
1690		r->r_offset;
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1691}
1692
1693static int addend_386_rel(struct elf_info *elf, Elf_Shdr *sechdr, Elf_Rela *r)
1694{
1695	unsigned int r_typ = ELF_R_TYPE(r->r_info);
1696	unsigned int *location = reloc_location(elf, sechdr, r);
1697
1698	switch (r_typ) {
1699	case R_386_32:
1700		r->r_addend = TO_NATIVE(*location);
1701		break;
1702	case R_386_PC32:
1703		r->r_addend = TO_NATIVE(*location) + 4;
1704		/* For CONFIG_RELOCATABLE=y */
1705		if (elf->hdr->e_type == ET_EXEC)
1706			r->r_addend += r->r_offset;
1707		break;
1708	}
1709	return 0;
1710}
1711
1712#ifndef R_ARM_CALL
1713#define R_ARM_CALL	28
1714#endif
1715#ifndef R_ARM_JUMP24
1716#define R_ARM_JUMP24	29
 
 
 
 
 
1717#endif
1718
1719#ifndef	R_ARM_THM_CALL
1720#define	R_ARM_THM_CALL		10
1721#endif
1722#ifndef	R_ARM_THM_JUMP24
1723#define	R_ARM_THM_JUMP24	30
 
1724#endif
1725#ifndef	R_ARM_THM_JUMP19
1726#define	R_ARM_THM_JUMP19	51
 
1727#endif
1728
1729static int addend_arm_rel(struct elf_info *elf, Elf_Shdr *sechdr, Elf_Rela *r)
 
1730{
1731	unsigned int r_typ = ELF_R_TYPE(r->r_info);
 
 
 
 
 
 
1732
1733	switch (r_typ) {
1734	case R_ARM_ABS32:
1735		/* From ARM ABI: (S + A) | T */
1736		r->r_addend = (int)(long)
1737			      (elf->symtab_start + ELF_R_SYM(r->r_info));
1738		break;
1739	case R_ARM_PC24:
1740	case R_ARM_CALL:
1741	case R_ARM_JUMP24:
1742	case R_ARM_THM_CALL:
1743	case R_ARM_THM_JUMP24:
1744	case R_ARM_THM_JUMP19:
1745		/* From ARM ABI: ((S + A) | T) - P */
1746		r->r_addend = (int)(long)(elf->hdr +
1747			      sechdr->sh_offset +
1748			      (r->r_offset - sechdr->sh_addr));
1749		break;
1750	default:
1751		return 1;
1752	}
1753	return 0;
1754}
1755
1756static int addend_mips_rel(struct elf_info *elf, Elf_Shdr *sechdr, Elf_Rela *r)
1757{
1758	unsigned int r_typ = ELF_R_TYPE(r->r_info);
1759	unsigned int *location = reloc_location(elf, sechdr, r);
1760	unsigned int inst;
1761
1762	if (r_typ == R_MIPS_HI16)
1763		return 1;	/* skip this */
1764	inst = TO_NATIVE(*location);
1765	switch (r_typ) {
1766	case R_MIPS_LO16:
1767		r->r_addend = inst & 0xffff;
1768		break;
1769	case R_MIPS_26:
1770		r->r_addend = (inst & 0x03ffffff) << 2;
1771		break;
1772	case R_MIPS_32:
1773		r->r_addend = inst;
1774		break;
1775	}
1776	return 0;
 
 
 
 
 
 
 
1777}
1778
1779static void section_rela(const char *modname, struct elf_info *elf,
1780			 Elf_Shdr *sechdr)
 
1781{
1782	Elf_Sym  *sym;
1783	Elf_Rela *rela;
1784	Elf_Rela r;
1785	unsigned int r_sym;
1786	const char *fromsec;
1787
1788	Elf_Rela *start = (void *)elf->hdr + sechdr->sh_offset;
1789	Elf_Rela *stop  = (void *)start + sechdr->sh_size;
1790
1791	fromsec = sech_name(elf, sechdr);
1792	fromsec += strlen(".rela");
1793	/* if from section (name) is know good then skip it */
1794	if (match(fromsec, section_white_list))
1795		return;
1796
1797	for (rela = start; rela < stop; rela++) {
1798		r.r_offset = TO_NATIVE(rela->r_offset);
1799#if KERNEL_ELFCLASS == ELFCLASS64
1800		if (elf->hdr->e_machine == EM_MIPS) {
1801			unsigned int r_typ;
1802			r_sym = ELF64_MIPS_R_SYM(rela->r_info);
1803			r_sym = TO_NATIVE(r_sym);
1804			r_typ = ELF64_MIPS_R_TYPE(rela->r_info);
1805			r.r_info = ELF64_R_INFO(r_sym, r_typ);
1806		} else {
1807			r.r_info = TO_NATIVE(rela->r_info);
1808			r_sym = ELF_R_SYM(r.r_info);
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1809		}
1810#else
1811		r.r_info = TO_NATIVE(rela->r_info);
1812		r_sym = ELF_R_SYM(r.r_info);
1813#endif
1814		r.r_addend = TO_NATIVE(rela->r_addend);
1815		sym = elf->symtab_start + r_sym;
1816		/* Skip special sections */
1817		if (is_shndx_special(sym->st_shndx))
1818			continue;
1819		if (is_second_extable_reloc(start, rela, fromsec))
1820			find_extable_entry_size(fromsec, &r);
1821		check_section_mismatch(modname, elf, &r, sym, fromsec);
1822	}
1823}
1824
1825static void section_rel(const char *modname, struct elf_info *elf,
1826			Elf_Shdr *sechdr)
 
1827{
1828	Elf_Sym *sym;
1829	Elf_Rel *rel;
1830	Elf_Rela r;
1831	unsigned int r_sym;
1832	const char *fromsec;
1833
1834	Elf_Rel *start = (void *)elf->hdr + sechdr->sh_offset;
1835	Elf_Rel *stop  = (void *)start + sechdr->sh_size;
1836
1837	fromsec = sech_name(elf, sechdr);
1838	fromsec += strlen(".rel");
1839	/* if from section (name) is know good then skip it */
1840	if (match(fromsec, section_white_list))
1841		return;
1842
1843	for (rel = start; rel < stop; rel++) {
1844		r.r_offset = TO_NATIVE(rel->r_offset);
1845#if KERNEL_ELFCLASS == ELFCLASS64
1846		if (elf->hdr->e_machine == EM_MIPS) {
1847			unsigned int r_typ;
1848			r_sym = ELF64_MIPS_R_SYM(rel->r_info);
1849			r_sym = TO_NATIVE(r_sym);
1850			r_typ = ELF64_MIPS_R_TYPE(rel->r_info);
1851			r.r_info = ELF64_R_INFO(r_sym, r_typ);
1852		} else {
1853			r.r_info = TO_NATIVE(rel->r_info);
1854			r_sym = ELF_R_SYM(r.r_info);
1855		}
1856#else
1857		r.r_info = TO_NATIVE(rel->r_info);
1858		r_sym = ELF_R_SYM(r.r_info);
1859#endif
1860		r.r_addend = 0;
1861		switch (elf->hdr->e_machine) {
1862		case EM_386:
1863			if (addend_386_rel(elf, sechdr, &r))
1864				continue;
1865			break;
1866		case EM_ARM:
1867			if (addend_arm_rel(elf, sechdr, &r))
1868				continue;
1869			break;
1870		case EM_MIPS:
1871			if (addend_mips_rel(elf, sechdr, &r))
1872				continue;
1873			break;
 
 
1874		}
1875		sym = elf->symtab_start + r_sym;
1876		/* Skip special sections */
1877		if (is_shndx_special(sym->st_shndx))
1878			continue;
1879		if (is_second_extable_reloc(start, rel, fromsec))
1880			find_extable_entry_size(fromsec, &r);
1881		check_section_mismatch(modname, elf, &r, sym, fromsec);
1882	}
1883}
1884
1885/**
1886 * A module includes a number of sections that are discarded
1887 * either when loaded or when used as built-in.
1888 * For loaded modules all functions marked __init and all data
1889 * marked __initdata will be discarded when the module has been initialized.
1890 * Likewise for modules used built-in the sections marked __exit
1891 * are discarded because __exit marked function are supposed to be called
1892 * only when a module is unloaded which never happens for built-in modules.
1893 * The check_sec_ref() function traverses all relocation records
1894 * to find all references to a section that reference a section that will
1895 * be discarded and warns about it.
1896 **/
1897static void check_sec_ref(struct module *mod, const char *modname,
1898			  struct elf_info *elf)
1899{
1900	int i;
1901	Elf_Shdr *sechdrs = elf->sechdrs;
1902
1903	/* Walk through all sections */
1904	for (i = 0; i < elf->num_sections; i++) {
1905		check_section(modname, elf, &elf->sechdrs[i]);
 
 
1906		/* We want to process only relocation sections and not .init */
1907		if (sechdrs[i].sh_type == SHT_RELA)
1908			section_rela(modname, elf, &elf->sechdrs[i]);
1909		else if (sechdrs[i].sh_type == SHT_REL)
1910			section_rel(modname, elf, &elf->sechdrs[i]);
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1911	}
1912}
1913
1914static char *remove_dot(char *s)
1915{
1916	size_t n = strcspn(s, ".");
1917
1918	if (n && s[n]) {
1919		size_t m = strspn(s + n + 1, "0123456789");
1920		if (m && (s[n + m] == '.' || s[n + m] == 0))
1921			s[n] = 0;
1922	}
1923	return s;
1924}
1925
1926static void read_symbols(char *modname)
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1927{
1928	const char *symname;
1929	char *version;
1930	char *license;
 
1931	struct module *mod;
1932	struct elf_info info = { };
1933	Elf_Sym *sym;
1934
1935	if (!parse_elf(&info, modname))
1936		return;
1937
1938	mod = new_module(modname);
 
 
 
1939
1940	/* When there's no vmlinux, don't print warnings about
1941	 * unresolved symbols (since there'll be too many ;) */
1942	if (is_vmlinux(modname)) {
1943		have_vmlinux = 1;
1944		mod->skip = 1;
1945	}
1946
1947	license = get_modinfo(info.modinfo, info.modinfo_len, "license");
1948	if (info.modinfo && !license && !is_vmlinux(modname))
1949		warn("modpost: missing MODULE_LICENSE() in %s\n"
1950		     "see include/linux/module.h for "
1951		     "more information\n", modname);
1952	while (license) {
1953		if (license_is_gpl_compatible(license))
1954			mod->gpl_compatible = 1;
1955		else {
1956			mod->gpl_compatible = 0;
1957			break;
 
 
1958		}
1959		license = get_next_modinfo(info.modinfo, info.modinfo_len,
1960					   "license", license);
 
1961	}
1962
1963	for (sym = info.symtab_start; sym < info.symtab_stop; sym++) {
1964		symname = remove_dot(info.strtab + sym->st_name);
1965
1966		handle_modversions(mod, &info, sym, symname);
1967		handle_moddevtable(mod, &info, sym, symname);
1968	}
1969	if (!is_vmlinux(modname) ||
1970	     (is_vmlinux(modname) && vmlinux_section_warnings))
1971		check_sec_ref(mod, modname, &info);
1972
1973	version = get_modinfo(info.modinfo, info.modinfo_len, "version");
1974	if (version)
1975		maybe_frob_rcs_version(modname, version, info.modinfo,
1976				       version - (char *)info.hdr);
1977	if (version || (all_versions && !is_vmlinux(modname)))
1978		get_src_version(modname, mod->srcversion,
1979				sizeof(mod->srcversion)-1);
1980
1981	parse_elf_finish(&info);
1982
1983	/* Our trick to get versioning for module struct etc. - it's
1984	 * never passed as an argument to an exported function, so
1985	 * the automatic versioning doesn't pick it up, but it's really
1986	 * important anyhow */
1987	if (modversions)
1988		mod->unres = alloc_symbol("module_layout", 0, mod->unres);
 
 
 
 
 
1989}
1990
1991static void read_symbols_from_files(const char *filename)
1992{
1993	FILE *in = stdin;
1994	char fname[PATH_MAX];
1995
1996	if (strcmp(filename, "-") != 0) {
1997		in = fopen(filename, "r");
1998		if (!in)
1999			fatal("Can't open filenames file %s: %m", filename);
2000	}
2001
2002	while (fgets(fname, PATH_MAX, in) != NULL) {
2003		if (strends(fname, "\n"))
2004			fname[strlen(fname)-1] = '\0';
2005		read_symbols(fname);
2006	}
2007
2008	if (in != stdin)
2009		fclose(in);
2010}
2011
2012#define SZ 500
2013
2014/* We first write the generated file into memory using the
2015 * following helper, then compare to the file on disk and
2016 * only update the later if anything changed */
2017
2018void __attribute__((format(printf, 2, 3))) buf_printf(struct buffer *buf,
2019						      const char *fmt, ...)
2020{
2021	char tmp[SZ];
2022	int len;
2023	va_list ap;
2024
2025	va_start(ap, fmt);
2026	len = vsnprintf(tmp, SZ, fmt, ap);
2027	buf_write(buf, tmp, len);
2028	va_end(ap);
2029}
2030
2031void buf_write(struct buffer *buf, const char *s, int len)
2032{
2033	if (buf->size - buf->pos < len) {
2034		buf->size += len + SZ;
2035		buf->p = realloc(buf->p, buf->size);
2036	}
2037	strncpy(buf->p + buf->pos, s, len);
2038	buf->pos += len;
2039}
2040
2041static void check_for_gpl_usage(enum export exp, const char *m, const char *s)
2042{
2043	const char *e = is_vmlinux(m) ?"":".ko";
2044
2045	switch (exp) {
2046	case export_gpl:
2047		fatal("modpost: GPL-incompatible module %s%s "
2048		      "uses GPL-only symbol '%s'\n", m, e, s);
2049		break;
2050	case export_unused_gpl:
2051		fatal("modpost: GPL-incompatible module %s%s "
2052		      "uses GPL-only symbol marked UNUSED '%s'\n", m, e, s);
2053		break;
2054	case export_gpl_future:
2055		warn("modpost: GPL-incompatible module %s%s "
2056		      "uses future GPL-only symbol '%s'\n", m, e, s);
2057		break;
2058	case export_plain:
2059	case export_unused:
2060	case export_unknown:
2061		/* ignore */
2062		break;
2063	}
2064}
2065
2066static void check_for_unused(enum export exp, const char *m, const char *s)
2067{
2068	const char *e = is_vmlinux(m) ?"":".ko";
2069
2070	switch (exp) {
2071	case export_unused:
2072	case export_unused_gpl:
2073		warn("modpost: module %s%s "
2074		      "uses symbol '%s' marked UNUSED\n", m, e, s);
2075		break;
2076	default:
2077		/* ignore */
2078		break;
2079	}
2080}
2081
2082static void check_exports(struct module *mod)
2083{
2084	struct symbol *s, *exp;
2085
2086	for (s = mod->unres; s; s = s->next) {
2087		const char *basename;
2088		exp = find_symbol(s->name);
2089		if (!exp || exp->module == mod)
 
 
 
 
 
 
 
 
 
2090			continue;
 
 
 
 
 
 
 
2091		basename = strrchr(mod->name, '/');
2092		if (basename)
2093			basename++;
2094		else
2095			basename = mod->name;
2096		if (!mod->gpl_compatible)
2097			check_for_gpl_usage(exp->export, basename, exp->name);
2098		check_for_unused(exp->export, basename, exp->name);
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
2099	}
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
2100}
2101
2102/**
2103 * Header for the generated file
2104 **/
2105static void add_header(struct buffer *b, struct module *mod)
2106{
2107	buf_printf(b, "#include <linux/module.h>\n");
2108	buf_printf(b, "#include <linux/vermagic.h>\n");
2109	buf_printf(b, "#include <linux/compiler.h>\n");
2110	buf_printf(b, "\n");
2111	buf_printf(b, "MODULE_INFO(vermagic, VERMAGIC_STRING);\n");
2112	buf_printf(b, "\n");
2113	buf_printf(b, "__visible struct module __this_module\n");
2114	buf_printf(b, "__attribute__((section(\".gnu.linkonce.this_module\"))) = {\n");
2115	buf_printf(b, "\t.name = KBUILD_MODNAME,\n");
2116	if (mod->has_init)
2117		buf_printf(b, "\t.init = init_module,\n");
2118	if (mod->has_cleanup)
2119		buf_printf(b, "#ifdef CONFIG_MODULE_UNLOAD\n"
2120			      "\t.exit = cleanup_module,\n"
2121			      "#endif\n");
2122	buf_printf(b, "\t.arch = MODULE_ARCH_INIT,\n");
2123	buf_printf(b, "};\n");
2124}
2125
2126static void add_intree_flag(struct buffer *b, int is_intree)
2127{
2128	if (is_intree)
2129		buf_printf(b, "\nMODULE_INFO(intree, \"Y\");\n");
 
 
 
 
 
 
2130}
2131
2132static void add_staging_flag(struct buffer *b, const char *name)
2133{
2134	static const char *staging_dir = "drivers/staging";
2135
2136	if (strncmp(staging_dir, name, strlen(staging_dir)) == 0)
2137		buf_printf(b, "\nMODULE_INFO(staging, \"Y\");\n");
2138}
 
 
2139
2140/* In kernel, this size is defined in linux/module.h;
2141 * here we use Elf_Addr instead of long for covering cross-compile
2142 */
2143#define MODULE_NAME_LEN (64 - sizeof(Elf_Addr))
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
2144
2145/**
2146 * Record CRCs for unresolved symbols
2147 **/
2148static int add_versions(struct buffer *b, struct module *mod)
2149{
2150	struct symbol *s, *exp;
2151	int err = 0;
2152
2153	for (s = mod->unres; s; s = s->next) {
2154		exp = find_symbol(s->name);
2155		if (!exp || exp->module == mod) {
2156			if (have_vmlinux && !s->weak) {
2157				if (warn_unresolved) {
2158					warn("\"%s\" [%s.ko] undefined!\n",
2159					     s->name, mod->name);
2160				} else {
2161					merror("\"%s\" [%s.ko] undefined!\n",
2162					       s->name, mod->name);
2163					err = 1;
2164				}
2165			}
2166			continue;
2167		}
2168		s->module = exp->module;
2169		s->crc_valid = exp->crc_valid;
2170		s->crc = exp->crc;
2171	}
2172
2173	if (!modversions)
2174		return err;
2175
2176	buf_printf(b, "\n");
2177	buf_printf(b, "static const struct modversion_info ____versions[]\n");
2178	buf_printf(b, "__used\n");
2179	buf_printf(b, "__attribute__((section(\"__versions\"))) = {\n");
2180
2181	for (s = mod->unres; s; s = s->next) {
2182		if (!s->module)
2183			continue;
2184		if (!s->crc_valid) {
2185			warn("\"%s\" [%s.ko] has no CRC!\n",
2186				s->name, mod->name);
2187			continue;
2188		}
2189		if (strlen(s->name) >= MODULE_NAME_LEN) {
2190			merror("too long symbol \"%s\" [%s.ko]\n",
2191			       s->name, mod->name);
2192			err = 1;
2193			break;
2194		}
2195		buf_printf(b, "\t{ %#8x, __VMLINUX_SYMBOL_STR(%s) },\n",
2196			   s->crc, s->name);
2197	}
2198
2199	buf_printf(b, "};\n");
2200
2201	return err;
2202}
2203
2204static void add_depends(struct buffer *b, struct module *mod,
2205			struct module *modules)
2206{
2207	struct symbol *s;
2208	struct module *m;
2209	int first = 1;
2210
2211	for (m = modules; m; m = m->next)
2212		m->seen = is_vmlinux(m->name);
 
 
 
2213
2214	buf_printf(b, "\n");
2215	buf_printf(b, "static const char __module_depends[]\n");
2216	buf_printf(b, "__used\n");
2217	buf_printf(b, "__attribute__((section(\".modinfo\"))) =\n");
2218	buf_printf(b, "\"depends=");
2219	for (s = mod->unres; s; s = s->next) {
2220		const char *p;
2221		if (!s->module)
2222			continue;
2223
2224		if (s->module->seen)
2225			continue;
2226
2227		s->module->seen = 1;
2228		p = strrchr(s->module->name, '/');
2229		if (p)
2230			p++;
2231		else
2232			p = s->module->name;
2233		buf_printf(b, "%s%s", first ? "" : ",", p);
2234		first = 0;
2235	}
2236	buf_printf(b, "\";\n");
2237}
2238
2239static void add_srcversion(struct buffer *b, struct module *mod)
2240{
2241	if (mod->srcversion[0]) {
2242		buf_printf(b, "\n");
2243		buf_printf(b, "MODULE_INFO(srcversion, \"%s\");\n",
2244			   mod->srcversion);
2245	}
2246}
2247
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
2248static void write_if_changed(struct buffer *b, const char *fname)
2249{
2250	char *tmp;
2251	FILE *file;
2252	struct stat st;
2253
2254	file = fopen(fname, "r");
2255	if (!file)
2256		goto write;
2257
2258	if (fstat(fileno(file), &st) < 0)
2259		goto close_write;
2260
2261	if (st.st_size != b->pos)
2262		goto close_write;
2263
2264	tmp = NOFAIL(malloc(b->pos));
2265	if (fread(tmp, 1, b->pos, file) != b->pos)
2266		goto free_write;
2267
2268	if (memcmp(tmp, b->p, b->pos) != 0)
2269		goto free_write;
2270
2271	free(tmp);
2272	fclose(file);
2273	return;
2274
2275 free_write:
2276	free(tmp);
2277 close_write:
2278	fclose(file);
2279 write:
2280	file = fopen(fname, "w");
2281	if (!file) {
2282		perror(fname);
2283		exit(1);
2284	}
2285	if (fwrite(b->p, 1, b->pos, file) != b->pos) {
2286		perror(fname);
2287		exit(1);
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
2288	}
2289	fclose(file);
 
 
 
 
2290}
2291
2292/* parse Module.symvers file. line format:
2293 * 0x12345678<tab>symbol<tab>module[[<tab>export]<tab>something]
2294 **/
2295static void read_dump(const char *fname, unsigned int kernel)
2296{
2297	unsigned long size, pos = 0;
2298	void *file = grab_file(fname, &size);
2299	char *line;
2300
2301	if (!file)
 
2302		/* No symbol versions, silently ignore */
2303		return;
2304
2305	while ((line = get_next_line(&pos, file, size))) {
2306		char *symname, *modname, *d, *export, *end;
 
 
2307		unsigned int crc;
2308		struct module *mod;
2309		struct symbol *s;
 
2310
2311		if (!(symname = strchr(line, '\t')))
2312			goto fail;
2313		*symname++ = '\0';
2314		if (!(modname = strchr(symname, '\t')))
2315			goto fail;
2316		*modname++ = '\0';
2317		if ((export = strchr(modname, '\t')) != NULL)
2318			*export++ = '\0';
2319		if (export && ((end = strchr(export, '\t')) != NULL))
2320			*end = '\0';
 
 
 
2321		crc = strtoul(line, &d, 16);
2322		if (*symname == '\0' || *modname == '\0' || *d != '\0')
2323			goto fail;
2324		mod = find_module(modname);
 
 
 
 
 
 
 
 
 
 
2325		if (!mod) {
2326			if (is_vmlinux(modname))
2327				have_vmlinux = 1;
2328			mod = new_module(modname);
2329			mod->skip = 1;
2330		}
2331		s = sym_add_exported(symname, mod, export_no(export));
2332		s->kernel    = kernel;
2333		s->preloaded = 1;
2334		sym_update_crc(symname, mod, crc, export_no(export));
2335	}
2336	release_file(file, size);
2337	return;
2338fail:
2339	release_file(file, size);
2340	fatal("parse error in symbol dump file\n");
2341}
2342
2343/* For normal builds always dump all symbols.
2344 * For external modules only dump symbols
2345 * that are not read from kernel Module.symvers.
2346 **/
2347static int dump_sym(struct symbol *sym)
2348{
2349	if (!external_module)
2350		return 1;
2351	if (sym->vmlinux || sym->kernel)
2352		return 0;
2353	return 1;
2354}
2355
2356static void write_dump(const char *fname)
2357{
2358	struct buffer buf = { };
2359	struct symbol *symbol;
2360	int n;
2361
2362	for (n = 0; n < SYMBOL_HASH_SIZE ; n++) {
2363		symbol = symbolhash[n];
2364		while (symbol) {
2365			if (dump_sym(symbol))
2366				buf_printf(&buf, "0x%08x\t%s\t%s\t%s\n",
2367					symbol->crc, symbol->name,
2368					symbol->module->name,
2369					export_str(symbol->export));
2370			symbol = symbol->next;
 
 
2371		}
2372	}
2373	write_if_changed(&buf, fname);
 
2374}
2375
2376struct ext_sym_list {
2377	struct ext_sym_list *next;
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
2378	const char *file;
2379};
2380
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
2381int main(int argc, char **argv)
2382{
2383	struct module *mod;
2384	struct buffer buf = { };
2385	char *kernel_read = NULL, *module_read = NULL;
2386	char *dump_write = NULL, *files_source = NULL;
2387	int opt;
2388	int err;
2389	struct ext_sym_list *extsym_iter;
2390	struct ext_sym_list *extsym_start = NULL;
2391
2392	while ((opt = getopt(argc, argv, "i:I:e:mnsST:o:awM:K:E")) != -1) {
2393		switch (opt) {
2394		case 'i':
2395			kernel_read = optarg;
2396			break;
2397		case 'I':
2398			module_read = optarg;
2399			external_module = 1;
 
2400			break;
2401		case 'e':
2402			external_module = 1;
2403			extsym_iter =
2404			   NOFAIL(malloc(sizeof(*extsym_iter)));
2405			extsym_iter->next = extsym_start;
2406			extsym_iter->file = optarg;
2407			extsym_start = extsym_iter;
2408			break;
2409		case 'm':
2410			modversions = 1;
2411			break;
2412		case 'n':
2413			ignore_missing_files = 1;
2414			break;
2415		case 'o':
2416			dump_write = optarg;
2417			break;
2418		case 'a':
2419			all_versions = 1;
2420			break;
2421		case 's':
2422			vmlinux_section_warnings = 0;
2423			break;
2424		case 'S':
2425			sec_mismatch_verbose = 0;
2426			break;
2427		case 'T':
2428			files_source = optarg;
2429			break;
 
 
 
 
 
 
 
 
 
2430		case 'w':
2431			warn_unresolved = 1;
2432			break;
2433		case 'E':
2434			sec_mismatch_fatal = 1;
 
 
 
 
 
 
2435			break;
2436		default:
2437			exit(1);
2438		}
2439	}
2440
2441	if (kernel_read)
2442		read_dump(kernel_read, 1);
2443	if (module_read)
2444		read_dump(module_read, 0);
2445	while (extsym_start) {
2446		read_dump(extsym_start->file, 0);
2447		extsym_iter = extsym_start->next;
2448		free(extsym_start);
2449		extsym_start = extsym_iter;
2450	}
2451
2452	while (optind < argc)
2453		read_symbols(argv[optind++]);
2454
2455	if (files_source)
2456		read_symbols_from_files(files_source);
2457
2458	for (mod = modules; mod; mod = mod->next) {
2459		if (mod->skip)
2460			continue;
 
 
2461		check_exports(mod);
2462	}
2463
2464	err = 0;
2465
2466	for (mod = modules; mod; mod = mod->next) {
2467		char fname[PATH_MAX];
2468
2469		if (mod->skip)
 
2470			continue;
2471
2472		buf.pos = 0;
 
 
 
 
2473
2474		add_header(&buf, mod);
2475		add_intree_flag(&buf, !external_module);
2476		add_staging_flag(&buf, mod->name);
2477		err |= add_versions(&buf, mod);
2478		add_depends(&buf, mod, modules);
2479		add_moddevtable(&buf, mod);
2480		add_srcversion(&buf, mod);
2481
2482		sprintf(fname, "%s.mod.c", mod->name);
2483		write_if_changed(&buf, fname);
2484	}
2485	if (dump_write)
2486		write_dump(dump_write);
2487	if (sec_mismatch_count) {
2488		if (!sec_mismatch_verbose) {
2489			warn("modpost: Found %d section mismatch(es).\n"
2490			     "To see full details build your kernel with:\n"
2491			     "'make CONFIG_DEBUG_SECTION_MISMATCH=y'\n",
2492			     sec_mismatch_count);
2493		}
2494		if (sec_mismatch_fatal) {
2495			fatal("modpost: Section mismatches detected.\n"
2496			      "Set CONFIG_SECTION_MISMATCH_WARN_ONLY=y to allow them.\n");
2497		}
2498	}
2499
2500	return err;
2501}