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/* In kernel, this size is defined in linux/module.h;
  51 * here we use Elf_Addr instead of long for covering cross-compile
  52 */
  53
  54#define MODULE_NAME_LEN (64 - sizeof(Elf_Addr))
  55
  56#define PRINTF __attribute__ ((format (printf, 1, 2)))
  57
  58PRINTF void fatal(const char *fmt, ...)
  59{
  60	va_list arglist;
  61
  62	fprintf(stderr, "FATAL: ");
  63
  64	va_start(arglist, fmt);
  65	vfprintf(stderr, fmt, arglist);
  66	va_end(arglist);
  67
  68	exit(1);
  69}
  70
  71PRINTF void warn(const char *fmt, ...)
  72{
  73	va_list arglist;
  74
  75	fprintf(stderr, "WARNING: ");
  76
  77	va_start(arglist, fmt);
  78	vfprintf(stderr, fmt, arglist);
  79	va_end(arglist);
  80}
  81
  82PRINTF void merror(const char *fmt, ...)
  83{
  84	va_list arglist;
  85
  86	fprintf(stderr, "ERROR: ");
  87
  88	va_start(arglist, fmt);
  89	vfprintf(stderr, fmt, arglist);
  90	va_end(arglist);
  91}
  92
  93static inline bool strends(const char *str, const char *postfix)
  94{
  95	if (strlen(str) < strlen(postfix))
  96		return false;
  97
  98	return strcmp(str + strlen(str) - strlen(postfix), postfix) == 0;
  99}
 100
 101static int is_vmlinux(const char *modname)
 102{
 103	const char *myname;
 104
 105	myname = strrchr(modname, '/');
 106	if (myname)
 107		myname++;
 108	else
 109		myname = modname;
 110
 111	return (strcmp(myname, "vmlinux") == 0) ||
 112	       (strcmp(myname, "vmlinux.o") == 0);
 113}
 114
 115void *do_nofail(void *ptr, const char *expr)
 116{
 117	if (!ptr)
 118		fatal("modpost: Memory allocation failure: %s.\n", expr);
 119
 120	return ptr;
 121}
 122
 123/* A list of all modules we processed */
 124static struct module *modules;
 125
 126static struct module *find_module(char *modname)
 127{
 128	struct module *mod;
 129
 130	for (mod = modules; mod; mod = mod->next)
 131		if (strcmp(mod->name, modname) == 0)
 132			break;
 133	return mod;
 134}
 135
 136static struct module *new_module(const char *modname)
 137{
 138	struct module *mod;
 139	char *p;
 140
 141	mod = NOFAIL(malloc(sizeof(*mod)));
 142	memset(mod, 0, sizeof(*mod));
 143	p = NOFAIL(strdup(modname));
 144
 145	/* strip trailing .o */
 146	if (strends(p, ".o")) {
 147		p[strlen(p) - 2] = '\0';
 148		mod->is_dot_o = 1;
 149	}
 150
 151	/* add to list */
 152	mod->name = p;
 153	mod->gpl_compatible = -1;
 154	mod->next = modules;
 155	modules = mod;
 156
 157	return mod;
 158}
 159
 160/* A hash of all exported symbols,
 161 * struct symbol is also used for lists of unresolved symbols */
 162
 163#define SYMBOL_HASH_SIZE 1024
 164
 165struct symbol {
 166	struct symbol *next;
 167	struct module *module;
 168	unsigned int crc;
 169	int crc_valid;
 
 170	unsigned int weak:1;
 171	unsigned int vmlinux:1;    /* 1 if symbol is defined in vmlinux */
 172	unsigned int kernel:1;     /* 1 if symbol is from kernel
 173				    *  (only for external modules) **/
 174	unsigned int preloaded:1;  /* 1 if symbol from Module.symvers, or crc */
 
 175	enum export  export;       /* Type of export */
 176	char name[0];
 177};
 178
 179static struct symbol *symbolhash[SYMBOL_HASH_SIZE];
 180
 181/* This is based on the hash agorithm from gdbm, via tdb */
 182static inline unsigned int tdb_hash(const char *name)
 183{
 184	unsigned value;	/* Used to compute the hash value.  */
 185	unsigned   i;	/* Used to cycle through random values. */
 186
 187	/* Set the initial value from the key size. */
 188	for (value = 0x238F13AF * strlen(name), i = 0; name[i]; i++)
 189		value = (value + (((unsigned char *)name)[i] << (i*5 % 24)));
 190
 191	return (1103515243 * value + 12345);
 192}
 193
 194/**
 195 * Allocate a new symbols for use in the hash of exported symbols or
 196 * the list of unresolved symbols per module
 197 **/
 198static struct symbol *alloc_symbol(const char *name, unsigned int weak,
 199				   struct symbol *next)
 200{
 201	struct symbol *s = NOFAIL(malloc(sizeof(*s) + strlen(name) + 1));
 202
 203	memset(s, 0, sizeof(*s));
 204	strcpy(s->name, name);
 205	s->weak = weak;
 206	s->next = next;
 
 207	return s;
 208}
 209
 210/* For the hash of exported symbols */
 211static struct symbol *new_symbol(const char *name, struct module *module,
 212				 enum export export)
 213{
 214	unsigned int hash;
 215	struct symbol *new;
 216
 217	hash = tdb_hash(name) % SYMBOL_HASH_SIZE;
 218	new = symbolhash[hash] = alloc_symbol(name, 0, symbolhash[hash]);
 219	new->module = module;
 220	new->export = export;
 221	return new;
 222}
 223
 224static struct symbol *find_symbol(const char *name)
 225{
 226	struct symbol *s;
 227
 228	/* For our purposes, .foo matches foo.  PPC64 needs this. */
 229	if (name[0] == '.')
 230		name++;
 231
 232	for (s = symbolhash[tdb_hash(name) % SYMBOL_HASH_SIZE]; s; s = s->next) {
 233		if (strcmp(s->name, name) == 0)
 234			return s;
 235	}
 236	return NULL;
 237}
 238
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 239static const struct {
 240	const char *str;
 241	enum export export;
 242} export_list[] = {
 243	{ .str = "EXPORT_SYMBOL",            .export = export_plain },
 244	{ .str = "EXPORT_UNUSED_SYMBOL",     .export = export_unused },
 245	{ .str = "EXPORT_SYMBOL_GPL",        .export = export_gpl },
 246	{ .str = "EXPORT_UNUSED_SYMBOL_GPL", .export = export_unused_gpl },
 247	{ .str = "EXPORT_SYMBOL_GPL_FUTURE", .export = export_gpl_future },
 248	{ .str = "(unknown)",                .export = export_unknown },
 249};
 250
 251
 252static const char *export_str(enum export ex)
 253{
 254	return export_list[ex].str;
 255}
 256
 257static enum export export_no(const char *s)
 258{
 259	int i;
 260
 261	if (!s)
 262		return export_unknown;
 263	for (i = 0; export_list[i].export != export_unknown; i++) {
 264		if (strcmp(export_list[i].str, s) == 0)
 265			return export_list[i].export;
 266	}
 267	return export_unknown;
 268}
 269
 270static const char *sech_name(struct elf_info *elf, Elf_Shdr *sechdr)
 271{
 272	return (void *)elf->hdr +
 273		elf->sechdrs[elf->secindex_strings].sh_offset +
 274		sechdr->sh_name;
 275}
 276
 277static const char *sec_name(struct elf_info *elf, int secindex)
 278{
 279	return sech_name(elf, &elf->sechdrs[secindex]);
 280}
 281
 282#define strstarts(str, prefix) (strncmp(str, prefix, strlen(prefix)) == 0)
 283
 284static enum export export_from_secname(struct elf_info *elf, unsigned int sec)
 285{
 286	const char *secname = sec_name(elf, sec);
 287
 288	if (strstarts(secname, "___ksymtab+"))
 289		return export_plain;
 290	else if (strstarts(secname, "___ksymtab_unused+"))
 291		return export_unused;
 292	else if (strstarts(secname, "___ksymtab_gpl+"))
 293		return export_gpl;
 294	else if (strstarts(secname, "___ksymtab_unused_gpl+"))
 295		return export_unused_gpl;
 296	else if (strstarts(secname, "___ksymtab_gpl_future+"))
 297		return export_gpl_future;
 298	else
 299		return export_unknown;
 300}
 301
 302static enum export export_from_sec(struct elf_info *elf, unsigned int sec)
 303{
 304	if (sec == elf->export_sec)
 305		return export_plain;
 306	else if (sec == elf->export_unused_sec)
 307		return export_unused;
 308	else if (sec == elf->export_gpl_sec)
 309		return export_gpl;
 310	else if (sec == elf->export_unused_gpl_sec)
 311		return export_unused_gpl;
 312	else if (sec == elf->export_gpl_future_sec)
 313		return export_gpl_future;
 314	else
 315		return export_unknown;
 316}
 317
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 318/**
 319 * Add an exported symbol - it may have already been added without a
 320 * CRC, in this case just update the CRC
 321 **/
 322static struct symbol *sym_add_exported(const char *name, struct module *mod,
 323				       enum export export)
 324{
 325	struct symbol *s = find_symbol(name);
 326
 327	if (!s) {
 328		s = new_symbol(name, mod, export);
 329	} else {
 330		if (!s->preloaded) {
 331			warn("%s: '%s' exported twice. Previous export "
 332			     "was in %s%s\n", mod->name, name,
 333			     s->module->name,
 334			     is_vmlinux(s->module->name) ?"":".ko");
 335		} else {
 336			/* In case Module.symvers was out of date */
 337			s->module = mod;
 338		}
 339	}
 340	s->preloaded = 0;
 341	s->vmlinux   = is_vmlinux(mod->name);
 342	s->kernel    = 0;
 343	s->export    = export;
 344	return s;
 345}
 346
 347static void sym_update_crc(const char *name, struct module *mod,
 348			   unsigned int crc, enum export export)
 349{
 350	struct symbol *s = find_symbol(name);
 351
 352	if (!s) {
 353		s = new_symbol(name, mod, export);
 354		/* Don't complain when we find it later. */
 355		s->preloaded = 1;
 356	}
 357	s->crc = crc;
 358	s->crc_valid = 1;
 359}
 360
 361void *grab_file(const char *filename, unsigned long *size)
 362{
 363	struct stat st;
 364	void *map = MAP_FAILED;
 365	int fd;
 366
 367	fd = open(filename, O_RDONLY);
 368	if (fd < 0)
 369		return NULL;
 370	if (fstat(fd, &st))
 371		goto failed;
 372
 373	*size = st.st_size;
 374	map = mmap(NULL, *size, PROT_READ|PROT_WRITE, MAP_PRIVATE, fd, 0);
 375
 376failed:
 377	close(fd);
 378	if (map == MAP_FAILED)
 379		return NULL;
 380	return map;
 381}
 382
 383/**
 384  * Return a copy of the next line in a mmap'ed file.
 385  * spaces in the beginning of the line is trimmed away.
 386  * Return a pointer to a static buffer.
 387  **/
 388char *get_next_line(unsigned long *pos, void *file, unsigned long size)
 389{
 390	static char line[4096];
 391	int skip = 1;
 392	size_t len = 0;
 393	signed char *p = (signed char *)file + *pos;
 394	char *s = line;
 395
 396	for (; *pos < size ; (*pos)++) {
 397		if (skip && isspace(*p)) {
 398			p++;
 399			continue;
 400		}
 401		skip = 0;
 402		if (*p != '\n' && (*pos < size)) {
 403			len++;
 404			*s++ = *p++;
 405			if (len > 4095)
 406				break; /* Too long, stop */
 407		} else {
 408			/* End of string */
 409			*s = '\0';
 410			return line;
 411		}
 412	}
 413	/* End of buffer */
 414	return NULL;
 415}
 416
 417void release_file(void *file, unsigned long size)
 418{
 419	munmap(file, size);
 420}
 421
 422static int parse_elf(struct elf_info *info, const char *filename)
 423{
 424	unsigned int i;
 425	Elf_Ehdr *hdr;
 426	Elf_Shdr *sechdrs;
 427	Elf_Sym  *sym;
 428	const char *secstrings;
 429	unsigned int symtab_idx = ~0U, symtab_shndx_idx = ~0U;
 430
 431	hdr = grab_file(filename, &info->size);
 432	if (!hdr) {
 433		if (ignore_missing_files) {
 434			fprintf(stderr, "%s: %s (ignored)\n", filename,
 435				strerror(errno));
 436			return 0;
 437		}
 438		perror(filename);
 439		exit(1);
 440	}
 441	info->hdr = hdr;
 442	if (info->size < sizeof(*hdr)) {
 443		/* file too small, assume this is an empty .o file */
 444		return 0;
 445	}
 446	/* Is this a valid ELF file? */
 447	if ((hdr->e_ident[EI_MAG0] != ELFMAG0) ||
 448	    (hdr->e_ident[EI_MAG1] != ELFMAG1) ||
 449	    (hdr->e_ident[EI_MAG2] != ELFMAG2) ||
 450	    (hdr->e_ident[EI_MAG3] != ELFMAG3)) {
 451		/* Not an ELF file - silently ignore it */
 452		return 0;
 453	}
 454	/* Fix endianness in ELF header */
 455	hdr->e_type      = TO_NATIVE(hdr->e_type);
 456	hdr->e_machine   = TO_NATIVE(hdr->e_machine);
 457	hdr->e_version   = TO_NATIVE(hdr->e_version);
 458	hdr->e_entry     = TO_NATIVE(hdr->e_entry);
 459	hdr->e_phoff     = TO_NATIVE(hdr->e_phoff);
 460	hdr->e_shoff     = TO_NATIVE(hdr->e_shoff);
 461	hdr->e_flags     = TO_NATIVE(hdr->e_flags);
 462	hdr->e_ehsize    = TO_NATIVE(hdr->e_ehsize);
 463	hdr->e_phentsize = TO_NATIVE(hdr->e_phentsize);
 464	hdr->e_phnum     = TO_NATIVE(hdr->e_phnum);
 465	hdr->e_shentsize = TO_NATIVE(hdr->e_shentsize);
 466	hdr->e_shnum     = TO_NATIVE(hdr->e_shnum);
 467	hdr->e_shstrndx  = TO_NATIVE(hdr->e_shstrndx);
 468	sechdrs = (void *)hdr + hdr->e_shoff;
 469	info->sechdrs = sechdrs;
 470
 471	/* Check if file offset is correct */
 472	if (hdr->e_shoff > info->size) {
 473		fatal("section header offset=%lu in file '%s' is bigger than "
 474		      "filesize=%lu\n", (unsigned long)hdr->e_shoff,
 475		      filename, info->size);
 476		return 0;
 477	}
 478
 479	if (hdr->e_shnum == SHN_UNDEF) {
 480		/*
 481		 * There are more than 64k sections,
 482		 * read count from .sh_size.
 483		 */
 484		info->num_sections = TO_NATIVE(sechdrs[0].sh_size);
 485	}
 486	else {
 487		info->num_sections = hdr->e_shnum;
 488	}
 489	if (hdr->e_shstrndx == SHN_XINDEX) {
 490		info->secindex_strings = TO_NATIVE(sechdrs[0].sh_link);
 491	}
 492	else {
 493		info->secindex_strings = hdr->e_shstrndx;
 494	}
 495
 496	/* Fix endianness in section headers */
 497	for (i = 0; i < info->num_sections; i++) {
 498		sechdrs[i].sh_name      = TO_NATIVE(sechdrs[i].sh_name);
 499		sechdrs[i].sh_type      = TO_NATIVE(sechdrs[i].sh_type);
 500		sechdrs[i].sh_flags     = TO_NATIVE(sechdrs[i].sh_flags);
 501		sechdrs[i].sh_addr      = TO_NATIVE(sechdrs[i].sh_addr);
 502		sechdrs[i].sh_offset    = TO_NATIVE(sechdrs[i].sh_offset);
 503		sechdrs[i].sh_size      = TO_NATIVE(sechdrs[i].sh_size);
 504		sechdrs[i].sh_link      = TO_NATIVE(sechdrs[i].sh_link);
 505		sechdrs[i].sh_info      = TO_NATIVE(sechdrs[i].sh_info);
 506		sechdrs[i].sh_addralign = TO_NATIVE(sechdrs[i].sh_addralign);
 507		sechdrs[i].sh_entsize   = TO_NATIVE(sechdrs[i].sh_entsize);
 508	}
 509	/* Find symbol table. */
 510	secstrings = (void *)hdr + sechdrs[info->secindex_strings].sh_offset;
 511	for (i = 1; i < info->num_sections; i++) {
 512		const char *secname;
 513		int nobits = sechdrs[i].sh_type == SHT_NOBITS;
 514
 515		if (!nobits && sechdrs[i].sh_offset > info->size) {
 516			fatal("%s is truncated. sechdrs[i].sh_offset=%lu > "
 517			      "sizeof(*hrd)=%zu\n", filename,
 518			      (unsigned long)sechdrs[i].sh_offset,
 519			      sizeof(*hdr));
 520			return 0;
 521		}
 522		secname = secstrings + sechdrs[i].sh_name;
 523		if (strcmp(secname, ".modinfo") == 0) {
 524			if (nobits)
 525				fatal("%s has NOBITS .modinfo\n", filename);
 526			info->modinfo = (void *)hdr + sechdrs[i].sh_offset;
 527			info->modinfo_len = sechdrs[i].sh_size;
 528		} else if (strcmp(secname, "__ksymtab") == 0)
 529			info->export_sec = i;
 530		else if (strcmp(secname, "__ksymtab_unused") == 0)
 531			info->export_unused_sec = i;
 532		else if (strcmp(secname, "__ksymtab_gpl") == 0)
 533			info->export_gpl_sec = i;
 534		else if (strcmp(secname, "__ksymtab_unused_gpl") == 0)
 535			info->export_unused_gpl_sec = i;
 536		else if (strcmp(secname, "__ksymtab_gpl_future") == 0)
 537			info->export_gpl_future_sec = i;
 
 
 
 
 538
 539		if (sechdrs[i].sh_type == SHT_SYMTAB) {
 540			unsigned int sh_link_idx;
 541			symtab_idx = i;
 542			info->symtab_start = (void *)hdr +
 543			    sechdrs[i].sh_offset;
 544			info->symtab_stop  = (void *)hdr +
 545			    sechdrs[i].sh_offset + sechdrs[i].sh_size;
 546			sh_link_idx = sechdrs[i].sh_link;
 547			info->strtab       = (void *)hdr +
 548			    sechdrs[sh_link_idx].sh_offset;
 549		}
 550
 551		/* 32bit section no. table? ("more than 64k sections") */
 552		if (sechdrs[i].sh_type == SHT_SYMTAB_SHNDX) {
 553			symtab_shndx_idx = i;
 554			info->symtab_shndx_start = (void *)hdr +
 555			    sechdrs[i].sh_offset;
 556			info->symtab_shndx_stop  = (void *)hdr +
 557			    sechdrs[i].sh_offset + sechdrs[i].sh_size;
 558		}
 559	}
 560	if (!info->symtab_start)
 561		fatal("%s has no symtab?\n", filename);
 562
 563	/* Fix endianness in symbols */
 564	for (sym = info->symtab_start; sym < info->symtab_stop; sym++) {
 565		sym->st_shndx = TO_NATIVE(sym->st_shndx);
 566		sym->st_name  = TO_NATIVE(sym->st_name);
 567		sym->st_value = TO_NATIVE(sym->st_value);
 568		sym->st_size  = TO_NATIVE(sym->st_size);
 569	}
 570
 571	if (symtab_shndx_idx != ~0U) {
 572		Elf32_Word *p;
 573		if (symtab_idx != sechdrs[symtab_shndx_idx].sh_link)
 574			fatal("%s: SYMTAB_SHNDX has bad sh_link: %u!=%u\n",
 575			      filename, sechdrs[symtab_shndx_idx].sh_link,
 576			      symtab_idx);
 577		/* Fix endianness */
 578		for (p = info->symtab_shndx_start; p < info->symtab_shndx_stop;
 579		     p++)
 580			*p = TO_NATIVE(*p);
 581	}
 582
 583	return 1;
 584}
 585
 586static void parse_elf_finish(struct elf_info *info)
 587{
 588	release_file(info->hdr, info->size);
 589}
 590
 591static int ignore_undef_symbol(struct elf_info *info, const char *symname)
 592{
 593	/* ignore __this_module, it will be resolved shortly */
 594	if (strcmp(symname, VMLINUX_SYMBOL_STR(__this_module)) == 0)
 595		return 1;
 596	/* ignore global offset table */
 597	if (strcmp(symname, "_GLOBAL_OFFSET_TABLE_") == 0)
 598		return 1;
 599	if (info->hdr->e_machine == EM_PPC)
 600		/* Special register function linked on all modules during final link of .ko */
 601		if (strncmp(symname, "_restgpr_", sizeof("_restgpr_") - 1) == 0 ||
 602		    strncmp(symname, "_savegpr_", sizeof("_savegpr_") - 1) == 0 ||
 603		    strncmp(symname, "_rest32gpr_", sizeof("_rest32gpr_") - 1) == 0 ||
 604		    strncmp(symname, "_save32gpr_", sizeof("_save32gpr_") - 1) == 0 ||
 605		    strncmp(symname, "_restvr_", sizeof("_restvr_") - 1) == 0 ||
 606		    strncmp(symname, "_savevr_", sizeof("_savevr_") - 1) == 0)
 607			return 1;
 608	if (info->hdr->e_machine == EM_PPC64)
 609		/* Special register function linked on all modules during final link of .ko */
 610		if (strncmp(symname, "_restgpr0_", sizeof("_restgpr0_") - 1) == 0 ||
 611		    strncmp(symname, "_savegpr0_", sizeof("_savegpr0_") - 1) == 0 ||
 612		    strncmp(symname, "_restvr_", sizeof("_restvr_") - 1) == 0 ||
 613		    strncmp(symname, "_savevr_", sizeof("_savevr_") - 1) == 0 ||
 614		    strcmp(symname, ".TOC.") == 0)
 615			return 1;
 616	/* Do not ignore this symbol */
 617	return 0;
 618}
 619
 620#define CRC_PFX     VMLINUX_SYMBOL_STR(__crc_)
 621#define KSYMTAB_PFX VMLINUX_SYMBOL_STR(__ksymtab_)
 622
 623static void handle_modversions(struct module *mod, struct elf_info *info,
 624			       Elf_Sym *sym, const char *symname)
 625{
 626	unsigned int crc;
 627	enum export export;
 628	bool is_crc = false;
 
 629
 630	if ((!is_vmlinux(mod->name) || mod->is_dot_o) &&
 631	    strncmp(symname, "__ksymtab", 9) == 0)
 632		export = export_from_secname(info, get_secindex(info, sym));
 633	else
 634		export = export_from_sec(info, get_secindex(info, sym));
 635
 636	/* CRC'd symbol */
 637	if (strncmp(symname, CRC_PFX, strlen(CRC_PFX)) == 0) {
 638		is_crc = true;
 639		crc = (unsigned int) sym->st_value;
 640		if (sym->st_shndx != SHN_UNDEF && sym->st_shndx != SHN_ABS) {
 641			unsigned int *crcp;
 642
 643			/* symbol points to the CRC in the ELF object */
 644			crcp = (void *)info->hdr + sym->st_value +
 645			       info->sechdrs[sym->st_shndx].sh_offset -
 646			       (info->hdr->e_type != ET_REL ?
 647				info->sechdrs[sym->st_shndx].sh_addr : 0);
 648			crc = *crcp;
 649		}
 650		sym_update_crc(symname + strlen(CRC_PFX), mod, crc,
 651				export);
 652	}
 653
 654	switch (sym->st_shndx) {
 655	case SHN_COMMON:
 656		if (!strncmp(symname, "__gnu_lto_", sizeof("__gnu_lto_")-1)) {
 657			/* Should warn here, but modpost runs before the linker */
 658		} else
 659			warn("\"%s\" [%s] is COMMON symbol\n", symname, mod->name);
 660		break;
 661	case SHN_UNDEF:
 662		/* undefined symbol */
 663		if (ELF_ST_BIND(sym->st_info) != STB_GLOBAL &&
 664		    ELF_ST_BIND(sym->st_info) != STB_WEAK)
 665			break;
 666		if (ignore_undef_symbol(info, symname))
 667			break;
 668/* cope with newer glibc (2.3.4 or higher) STT_ definition in elf.h */
 669#if defined(STT_REGISTER) || defined(STT_SPARC_REGISTER)
 670/* add compatibility with older glibc */
 671#ifndef STT_SPARC_REGISTER
 672#define STT_SPARC_REGISTER STT_REGISTER
 673#endif
 674		if (info->hdr->e_machine == EM_SPARC ||
 675		    info->hdr->e_machine == EM_SPARCV9) {
 676			/* Ignore register directives. */
 677			if (ELF_ST_TYPE(sym->st_info) == STT_SPARC_REGISTER)
 678				break;
 679			if (symname[0] == '.') {
 680				char *munged = strdup(symname);
 681				munged[0] = '_';
 682				munged[1] = toupper(munged[1]);
 683				symname = munged;
 684			}
 685		}
 686#endif
 687
 688#ifdef CONFIG_HAVE_UNDERSCORE_SYMBOL_PREFIX
 689		if (symname[0] != '_')
 690			break;
 691		else
 692			symname++;
 693#endif
 694		if (is_crc) {
 695			const char *e = is_vmlinux(mod->name) ?"":".ko";
 696			warn("EXPORT symbol \"%s\" [%s%s] version generation failed, symbol will not be versioned.\n", symname + strlen(CRC_PFX), mod->name, e);
 
 697		}
 698		mod->unres = alloc_symbol(symname,
 699					  ELF_ST_BIND(sym->st_info) == STB_WEAK,
 700					  mod->unres);
 701		break;
 702	default:
 703		/* All exported symbols */
 704		if (strncmp(symname, KSYMTAB_PFX, strlen(KSYMTAB_PFX)) == 0) {
 705			sym_add_exported(symname + strlen(KSYMTAB_PFX), mod,
 706					export);
 707		}
 708		if (strcmp(symname, VMLINUX_SYMBOL_STR(init_module)) == 0)
 709			mod->has_init = 1;
 710		if (strcmp(symname, VMLINUX_SYMBOL_STR(cleanup_module)) == 0)
 711			mod->has_cleanup = 1;
 712		break;
 713	}
 714}
 715
 716/**
 717 * Parse tag=value strings from .modinfo section
 718 **/
 719static char *next_string(char *string, unsigned long *secsize)
 720{
 721	/* Skip non-zero chars */
 722	while (string[0]) {
 723		string++;
 724		if ((*secsize)-- <= 1)
 725			return NULL;
 726	}
 727
 728	/* Skip any zero padding. */
 729	while (!string[0]) {
 730		string++;
 731		if ((*secsize)-- <= 1)
 732			return NULL;
 733	}
 734	return string;
 735}
 736
 737static char *get_next_modinfo(void *modinfo, unsigned long modinfo_len,
 738			      const char *tag, char *info)
 739{
 740	char *p;
 741	unsigned int taglen = strlen(tag);
 742	unsigned long size = modinfo_len;
 
 743
 744	if (info) {
 745		size -= info - (char *)modinfo;
 746		modinfo = next_string(info, &size);
 747	}
 748
 749	for (p = modinfo; p; p = next_string(p, &size)) {
 750		if (strncmp(p, tag, taglen) == 0 && p[taglen] == '=')
 751			return p + taglen + 1;
 752	}
 753	return NULL;
 754}
 755
 756static char *get_modinfo(void *modinfo, unsigned long modinfo_len,
 757			 const char *tag)
 758
 759{
 760	return get_next_modinfo(modinfo, modinfo_len, tag, NULL);
 761}
 762
 763/**
 764 * Test if string s ends in string sub
 765 * return 0 if match
 766 **/
 767static int strrcmp(const char *s, const char *sub)
 768{
 769	int slen, sublen;
 770
 771	if (!s || !sub)
 772		return 1;
 773
 774	slen = strlen(s);
 775	sublen = strlen(sub);
 776
 777	if ((slen == 0) || (sublen == 0))
 778		return 1;
 779
 780	if (sublen > slen)
 781		return 1;
 782
 783	return memcmp(s + slen - sublen, sub, sublen);
 784}
 785
 786static const char *sym_name(struct elf_info *elf, Elf_Sym *sym)
 787{
 788	if (sym)
 789		return elf->strtab + sym->st_name;
 790	else
 791		return "(unknown)";
 792}
 793
 794/* The pattern is an array of simple patterns.
 795 * "foo" will match an exact string equal to "foo"
 796 * "*foo" will match a string that ends with "foo"
 797 * "foo*" will match a string that begins with "foo"
 798 * "*foo*" will match a string that contains "foo"
 799 */
 800static int match(const char *sym, const char * const pat[])
 801{
 802	const char *p;
 803	while (*pat) {
 804		p = *pat++;
 805		const char *endp = p + strlen(p) - 1;
 806
 807		/* "*foo*" */
 808		if (*p == '*' && *endp == '*') {
 809			char *here, *bare = strndup(p + 1, strlen(p) - 2);
 
 810
 811			here = strstr(sym, bare);
 812			free(bare);
 813			if (here != NULL)
 814				return 1;
 815		}
 816		/* "*foo" */
 817		else if (*p == '*') {
 818			if (strrcmp(sym, p + 1) == 0)
 819				return 1;
 820		}
 821		/* "foo*" */
 822		else if (*endp == '*') {
 823			if (strncmp(sym, p, strlen(p) - 1) == 0)
 824				return 1;
 825		}
 826		/* no wildcards */
 827		else {
 828			if (strcmp(p, sym) == 0)
 829				return 1;
 830		}
 831	}
 832	/* no match */
 833	return 0;
 834}
 835
 836/* sections that we do not want to do full section mismatch check on */
 837static const char *const section_white_list[] =
 838{
 839	".comment*",
 840	".debug*",
 841	".cranges",		/* sh64 */
 842	".zdebug*",		/* Compressed debug sections. */
 843	".GCC.command.line",	/* record-gcc-switches */
 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	".discard.*",
 858	NULL
 859};
 860
 861/*
 862 * This is used to find sections missing the SHF_ALLOC flag.
 863 * The cause of this is often a section specified in assembler
 864 * without "ax" / "aw".
 865 */
 866static void check_section(const char *modname, struct elf_info *elf,
 867			  Elf_Shdr *sechdr)
 868{
 869	const char *sec = sech_name(elf, sechdr);
 870
 871	if (sechdr->sh_type == SHT_PROGBITS &&
 872	    !(sechdr->sh_flags & SHF_ALLOC) &&
 873	    !match(sec, section_white_list)) {
 874		warn("%s (%s): unexpected non-allocatable section.\n"
 875		     "Did you forget to use \"ax\"/\"aw\" in a .S file?\n"
 876		     "Note that for example <linux/init.h> contains\n"
 877		     "section definitions for use in .S files.\n\n",
 878		     modname, sec);
 879	}
 880}
 881
 882
 883
 884#define ALL_INIT_DATA_SECTIONS \
 885	".init.setup", ".init.rodata", ".meminit.rodata", \
 886	".init.data", ".meminit.data"
 887#define ALL_EXIT_DATA_SECTIONS \
 888	".exit.data", ".memexit.data"
 889
 890#define ALL_INIT_TEXT_SECTIONS \
 891	".init.text", ".meminit.text"
 892#define ALL_EXIT_TEXT_SECTIONS \
 893	".exit.text", ".memexit.text"
 894
 895#define ALL_PCI_INIT_SECTIONS	\
 896	".pci_fixup_early", ".pci_fixup_header", ".pci_fixup_final", \
 897	".pci_fixup_enable", ".pci_fixup_resume", \
 898	".pci_fixup_resume_early", ".pci_fixup_suspend"
 899
 900#define ALL_XXXINIT_SECTIONS MEM_INIT_SECTIONS
 901#define ALL_XXXEXIT_SECTIONS MEM_EXIT_SECTIONS
 902
 903#define ALL_INIT_SECTIONS INIT_SECTIONS, ALL_XXXINIT_SECTIONS
 904#define ALL_EXIT_SECTIONS EXIT_SECTIONS, ALL_XXXEXIT_SECTIONS
 905
 906#define DATA_SECTIONS ".data", ".data.rel"
 907#define TEXT_SECTIONS ".text", ".text.unlikely", ".sched.text", \
 908		".kprobes.text", ".cpuidle.text"
 909#define OTHER_TEXT_SECTIONS ".ref.text", ".head.text", ".spinlock.text", \
 910		".fixup", ".entry.text", ".exception.text", ".text.*", \
 911		".coldtext"
 912
 913#define INIT_SECTIONS      ".init.*"
 914#define MEM_INIT_SECTIONS  ".meminit.*"
 915
 916#define EXIT_SECTIONS      ".exit.*"
 917#define MEM_EXIT_SECTIONS  ".memexit.*"
 918
 919#define ALL_TEXT_SECTIONS  ALL_INIT_TEXT_SECTIONS, ALL_EXIT_TEXT_SECTIONS, \
 920		TEXT_SECTIONS, OTHER_TEXT_SECTIONS
 921
 922/* init data sections */
 923static const char *const init_data_sections[] =
 924	{ ALL_INIT_DATA_SECTIONS, NULL };
 925
 926/* all init sections */
 927static const char *const init_sections[] = { ALL_INIT_SECTIONS, NULL };
 928
 929/* All init and exit sections (code + data) */
 930static const char *const init_exit_sections[] =
 931	{ALL_INIT_SECTIONS, ALL_EXIT_SECTIONS, NULL };
 932
 933/* all text sections */
 934static const char *const text_sections[] = { ALL_TEXT_SECTIONS, NULL };
 935
 936/* data section */
 937static const char *const data_sections[] = { DATA_SECTIONS, NULL };
 938
 939
 940/* symbols in .data that may refer to init/exit sections */
 941#define DEFAULT_SYMBOL_WHITE_LIST					\
 942	"*driver",							\
 943	"*_template", /* scsi uses *_template a lot */			\
 944	"*_timer",    /* arm uses ops structures named _timer a lot */	\
 945	"*_sht",      /* scsi also used *_sht to some extent */		\
 946	"*_ops",							\
 947	"*_probe",							\
 948	"*_probe_one",							\
 949	"*_console"
 950
 951static const char *const head_sections[] = { ".head.text*", NULL };
 952static const char *const linker_symbols[] =
 953	{ "__init_begin", "_sinittext", "_einittext", NULL };
 954static const char *const optim_symbols[] = { "*.constprop.*", NULL };
 955
 956enum mismatch {
 957	TEXT_TO_ANY_INIT,
 958	DATA_TO_ANY_INIT,
 959	TEXT_TO_ANY_EXIT,
 960	DATA_TO_ANY_EXIT,
 961	XXXINIT_TO_SOME_INIT,
 962	XXXEXIT_TO_SOME_EXIT,
 963	ANY_INIT_TO_ANY_EXIT,
 964	ANY_EXIT_TO_ANY_INIT,
 965	EXPORT_TO_INIT_EXIT,
 966	EXTABLE_TO_NON_TEXT,
 967};
 968
 969/**
 970 * Describe how to match sections on different criterias:
 971 *
 972 * @fromsec: Array of sections to be matched.
 973 *
 974 * @bad_tosec: Relocations applied to a section in @fromsec to a section in
 975 * this array is forbidden (black-list).  Can be empty.
 976 *
 977 * @good_tosec: Relocations applied to a section in @fromsec must be
 978 * targetting sections in this array (white-list).  Can be empty.
 979 *
 980 * @mismatch: Type of mismatch.
 981 *
 982 * @symbol_white_list: Do not match a relocation to a symbol in this list
 983 * even if it is targetting a section in @bad_to_sec.
 984 *
 985 * @handler: Specific handler to call when a match is found.  If NULL,
 986 * default_mismatch_handler() will be called.
 987 *
 988 */
 989struct sectioncheck {
 990	const char *fromsec[20];
 991	const char *bad_tosec[20];
 992	const char *good_tosec[20];
 993	enum mismatch mismatch;
 994	const char *symbol_white_list[20];
 995	void (*handler)(const char *modname, struct elf_info *elf,
 996			const struct sectioncheck* const mismatch,
 997			Elf_Rela *r, Elf_Sym *sym, const char *fromsec);
 998
 999};
1000
1001static void extable_mismatch_handler(const char *modname, struct elf_info *elf,
1002				     const struct sectioncheck* const mismatch,
1003				     Elf_Rela *r, Elf_Sym *sym,
1004				     const char *fromsec);
1005
1006static const struct sectioncheck sectioncheck[] = {
1007/* Do not reference init/exit code/data from
1008 * normal code and data
1009 */
1010{
1011	.fromsec = { TEXT_SECTIONS, NULL },
1012	.bad_tosec = { ALL_INIT_SECTIONS, NULL },
1013	.mismatch = TEXT_TO_ANY_INIT,
1014	.symbol_white_list = { DEFAULT_SYMBOL_WHITE_LIST, NULL },
1015},
1016{
1017	.fromsec = { DATA_SECTIONS, NULL },
1018	.bad_tosec = { ALL_XXXINIT_SECTIONS, NULL },
1019	.mismatch = DATA_TO_ANY_INIT,
1020	.symbol_white_list = { DEFAULT_SYMBOL_WHITE_LIST, NULL },
1021},
1022{
1023	.fromsec = { DATA_SECTIONS, NULL },
1024	.bad_tosec = { INIT_SECTIONS, NULL },
1025	.mismatch = DATA_TO_ANY_INIT,
1026	.symbol_white_list = {
1027		"*_template", "*_timer", "*_sht", "*_ops",
1028		"*_probe", "*_probe_one", "*_console", NULL
1029	},
1030},
1031{
1032	.fromsec = { TEXT_SECTIONS, NULL },
1033	.bad_tosec = { ALL_EXIT_SECTIONS, NULL },
1034	.mismatch = TEXT_TO_ANY_EXIT,
1035	.symbol_white_list = { DEFAULT_SYMBOL_WHITE_LIST, NULL },
1036},
1037{
1038	.fromsec = { DATA_SECTIONS, NULL },
1039	.bad_tosec = { ALL_EXIT_SECTIONS, NULL },
1040	.mismatch = DATA_TO_ANY_EXIT,
1041	.symbol_white_list = { DEFAULT_SYMBOL_WHITE_LIST, NULL },
1042},
1043/* Do not reference init code/data from meminit code/data */
1044{
1045	.fromsec = { ALL_XXXINIT_SECTIONS, NULL },
1046	.bad_tosec = { INIT_SECTIONS, NULL },
1047	.mismatch = XXXINIT_TO_SOME_INIT,
1048	.symbol_white_list = { DEFAULT_SYMBOL_WHITE_LIST, NULL },
1049},
1050/* Do not reference exit code/data from memexit code/data */
1051{
1052	.fromsec = { ALL_XXXEXIT_SECTIONS, NULL },
1053	.bad_tosec = { EXIT_SECTIONS, NULL },
1054	.mismatch = XXXEXIT_TO_SOME_EXIT,
1055	.symbol_white_list = { DEFAULT_SYMBOL_WHITE_LIST, NULL },
1056},
1057/* Do not use exit code/data from init code */
1058{
1059	.fromsec = { ALL_INIT_SECTIONS, NULL },
1060	.bad_tosec = { ALL_EXIT_SECTIONS, NULL },
1061	.mismatch = ANY_INIT_TO_ANY_EXIT,
1062	.symbol_white_list = { DEFAULT_SYMBOL_WHITE_LIST, NULL },
1063},
1064/* Do not use init code/data from exit code */
1065{
1066	.fromsec = { ALL_EXIT_SECTIONS, NULL },
1067	.bad_tosec = { ALL_INIT_SECTIONS, NULL },
1068	.mismatch = ANY_EXIT_TO_ANY_INIT,
1069	.symbol_white_list = { DEFAULT_SYMBOL_WHITE_LIST, NULL },
1070},
1071{
1072	.fromsec = { ALL_PCI_INIT_SECTIONS, NULL },
1073	.bad_tosec = { INIT_SECTIONS, NULL },
1074	.mismatch = ANY_INIT_TO_ANY_EXIT,
1075	.symbol_white_list = { NULL },
1076},
1077/* Do not export init/exit functions or data */
1078{
1079	.fromsec = { "__ksymtab*", NULL },
1080	.bad_tosec = { INIT_SECTIONS, EXIT_SECTIONS, NULL },
1081	.mismatch = EXPORT_TO_INIT_EXIT,
1082	.symbol_white_list = { DEFAULT_SYMBOL_WHITE_LIST, NULL },
1083},
1084{
1085	.fromsec = { "__ex_table", NULL },
1086	/* If you're adding any new black-listed sections in here, consider
1087	 * adding a special 'printer' for them in scripts/check_extable.
1088	 */
1089	.bad_tosec = { ".altinstr_replacement", NULL },
1090	.good_tosec = {ALL_TEXT_SECTIONS , NULL},
1091	.mismatch = EXTABLE_TO_NON_TEXT,
1092	.handler = extable_mismatch_handler,
1093}
1094};
1095
1096static const struct sectioncheck *section_mismatch(
1097		const char *fromsec, const char *tosec)
1098{
1099	int i;
1100	int elems = sizeof(sectioncheck) / sizeof(struct sectioncheck);
1101	const struct sectioncheck *check = &sectioncheck[0];
1102
1103	/*
1104	 * The target section could be the SHT_NUL section when we're
1105	 * handling relocations to un-resolved symbols, trying to match it
1106	 * doesn't make much sense and causes build failures on parisc
1107	 * architectures.
1108	 */
1109	if (*tosec == '\0')
1110		return NULL;
1111
1112	for (i = 0; i < elems; i++) {
1113		if (match(fromsec, check->fromsec)) {
1114			if (check->bad_tosec[0] && match(tosec, check->bad_tosec))
1115				return check;
1116			if (check->good_tosec[0] && !match(tosec, check->good_tosec))
1117				return check;
1118		}
1119		check++;
1120	}
1121	return NULL;
1122}
1123
1124/**
1125 * Whitelist to allow certain references to pass with no warning.
1126 *
1127 * Pattern 1:
1128 *   If a module parameter is declared __initdata and permissions=0
1129 *   then this is legal despite the warning generated.
1130 *   We cannot see value of permissions here, so just ignore
1131 *   this pattern.
1132 *   The pattern is identified by:
1133 *   tosec   = .init.data
1134 *   fromsec = .data*
1135 *   atsym   =__param*
1136 *
1137 * Pattern 1a:
1138 *   module_param_call() ops can refer to __init set function if permissions=0
1139 *   The pattern is identified by:
1140 *   tosec   = .init.text
1141 *   fromsec = .data*
1142 *   atsym   = __param_ops_*
1143 *
1144 * Pattern 2:
1145 *   Many drivers utilise a *driver container with references to
1146 *   add, remove, probe functions etc.
1147 *   the pattern is identified by:
1148 *   tosec   = init or exit section
1149 *   fromsec = data section
1150 *   atsym = *driver, *_template, *_sht, *_ops, *_probe,
1151 *           *probe_one, *_console, *_timer
1152 *
1153 * Pattern 3:
1154 *   Whitelist all references from .head.text to any init section
1155 *
1156 * Pattern 4:
1157 *   Some symbols belong to init section but still it is ok to reference
1158 *   these from non-init sections as these symbols don't have any memory
1159 *   allocated for them and symbol address and value are same. So even
1160 *   if init section is freed, its ok to reference those symbols.
1161 *   For ex. symbols marking the init section boundaries.
1162 *   This pattern is identified by
1163 *   refsymname = __init_begin, _sinittext, _einittext
1164 *
1165 * Pattern 5:
1166 *   GCC may optimize static inlines when fed constant arg(s) resulting
1167 *   in functions like cpumask_empty() -- generating an associated symbol
1168 *   cpumask_empty.constprop.3 that appears in the audit.  If the const that
1169 *   is passed in comes from __init, like say nmi_ipi_mask, we get a
1170 *   meaningless section warning.  May need to add isra symbols too...
1171 *   This pattern is identified by
1172 *   tosec   = init section
1173 *   fromsec = text section
1174 *   refsymname = *.constprop.*
1175 *
 
 
 
 
 
 
 
 
1176 **/
1177static int secref_whitelist(const struct sectioncheck *mismatch,
1178			    const char *fromsec, const char *fromsym,
1179			    const char *tosec, const char *tosym)
1180{
1181	/* Check for pattern 1 */
1182	if (match(tosec, init_data_sections) &&
1183	    match(fromsec, data_sections) &&
1184	    (strncmp(fromsym, "__param", strlen("__param")) == 0))
1185		return 0;
1186
1187	/* Check for pattern 1a */
1188	if (strcmp(tosec, ".init.text") == 0 &&
1189	    match(fromsec, data_sections) &&
1190	    (strncmp(fromsym, "__param_ops_", strlen("__param_ops_")) == 0))
1191		return 0;
1192
1193	/* Check for pattern 2 */
1194	if (match(tosec, init_exit_sections) &&
1195	    match(fromsec, data_sections) &&
1196	    match(fromsym, mismatch->symbol_white_list))
1197		return 0;
1198
1199	/* Check for pattern 3 */
1200	if (match(fromsec, head_sections) &&
1201	    match(tosec, init_sections))
1202		return 0;
1203
1204	/* Check for pattern 4 */
1205	if (match(tosym, linker_symbols))
1206		return 0;
1207
1208	/* Check for pattern 5 */
1209	if (match(fromsec, text_sections) &&
1210	    match(tosec, init_sections) &&
1211	    match(fromsym, optim_symbols))
1212		return 0;
1213
 
 
 
 
1214	return 1;
1215}
1216
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1217/**
1218 * Find symbol based on relocation record info.
1219 * In some cases the symbol supplied is a valid symbol so
1220 * return refsym. If st_name != 0 we assume this is a valid symbol.
1221 * In other cases the symbol needs to be looked up in the symbol table
1222 * based on section and address.
1223 *  **/
1224static Elf_Sym *find_elf_symbol(struct elf_info *elf, Elf64_Sword addr,
1225				Elf_Sym *relsym)
1226{
1227	Elf_Sym *sym;
1228	Elf_Sym *near = NULL;
1229	Elf64_Sword distance = 20;
1230	Elf64_Sword d;
1231	unsigned int relsym_secindex;
1232
1233	if (relsym->st_name != 0)
1234		return relsym;
1235
1236	relsym_secindex = get_secindex(elf, relsym);
1237	for (sym = elf->symtab_start; sym < elf->symtab_stop; sym++) {
1238		if (get_secindex(elf, sym) != relsym_secindex)
1239			continue;
1240		if (ELF_ST_TYPE(sym->st_info) == STT_SECTION)
1241			continue;
 
 
1242		if (sym->st_value == addr)
1243			return sym;
1244		/* Find a symbol nearby - addr are maybe negative */
1245		d = sym->st_value - addr;
1246		if (d < 0)
1247			d = addr - sym->st_value;
1248		if (d < distance) {
1249			distance = d;
1250			near = sym;
1251		}
1252	}
1253	/* We need a close match */
1254	if (distance < 20)
1255		return near;
1256	else
1257		return NULL;
1258}
1259
1260static inline int is_arm_mapping_symbol(const char *str)
1261{
1262	return str[0] == '$' && strchr("axtd", str[1])
1263	       && (str[2] == '\0' || str[2] == '.');
1264}
1265
1266/*
1267 * If there's no name there, ignore it; likewise, ignore it if it's
1268 * one of the magic symbols emitted used by current ARM tools.
1269 *
1270 * Otherwise if find_symbols_between() returns those symbols, they'll
1271 * fail the whitelist tests and cause lots of false alarms ... fixable
1272 * only by merging __exit and __init sections into __text, bloating
1273 * the kernel (which is especially evil on embedded platforms).
1274 */
1275static inline int is_valid_name(struct elf_info *elf, Elf_Sym *sym)
1276{
1277	const char *name = elf->strtab + sym->st_name;
1278
1279	if (!name || !strlen(name))
1280		return 0;
1281	return !is_arm_mapping_symbol(name);
1282}
1283
1284/*
1285 * Find symbols before or equal addr and after addr - in the section sec.
1286 * If we find two symbols with equal offset prefer one with a valid name.
1287 * The ELF format may have a better way to detect what type of symbol
1288 * it is, but this works for now.
1289 **/
1290static Elf_Sym *find_elf_symbol2(struct elf_info *elf, Elf_Addr addr,
1291				 const char *sec)
1292{
1293	Elf_Sym *sym;
1294	Elf_Sym *near = NULL;
1295	Elf_Addr distance = ~0;
1296
1297	for (sym = elf->symtab_start; sym < elf->symtab_stop; sym++) {
1298		const char *symsec;
1299
1300		if (is_shndx_special(sym->st_shndx))
1301			continue;
1302		symsec = sec_name(elf, get_secindex(elf, sym));
1303		if (strcmp(symsec, sec) != 0)
1304			continue;
1305		if (!is_valid_name(elf, sym))
1306			continue;
1307		if (sym->st_value <= addr) {
1308			if ((addr - sym->st_value) < distance) {
1309				distance = addr - sym->st_value;
1310				near = sym;
1311			} else if ((addr - sym->st_value) == distance) {
1312				near = sym;
1313			}
1314		}
1315	}
1316	return near;
1317}
1318
1319/*
1320 * Convert a section name to the function/data attribute
1321 * .init.text => __init
1322 * .memexitconst => __memconst
1323 * etc.
1324 *
1325 * The memory of returned value has been allocated on a heap. The user of this
1326 * method should free it after usage.
1327*/
1328static char *sec2annotation(const char *s)
1329{
1330	if (match(s, init_exit_sections)) {
1331		char *p = malloc(20);
1332		char *r = p;
1333
1334		*p++ = '_';
1335		*p++ = '_';
1336		if (*s == '.')
1337			s++;
1338		while (*s && *s != '.')
1339			*p++ = *s++;
1340		*p = '\0';
1341		if (*s == '.')
1342			s++;
1343		if (strstr(s, "rodata") != NULL)
1344			strcat(p, "const ");
1345		else if (strstr(s, "data") != NULL)
1346			strcat(p, "data ");
1347		else
1348			strcat(p, " ");
1349		return r;
1350	} else {
1351		return strdup("");
1352	}
1353}
1354
1355static int is_function(Elf_Sym *sym)
1356{
1357	if (sym)
1358		return ELF_ST_TYPE(sym->st_info) == STT_FUNC;
1359	else
1360		return -1;
1361}
1362
1363static void print_section_list(const char * const list[20])
1364{
1365	const char *const *s = list;
1366
1367	while (*s) {
1368		fprintf(stderr, "%s", *s);
1369		s++;
1370		if (*s)
1371			fprintf(stderr, ", ");
1372	}
1373	fprintf(stderr, "\n");
1374}
1375
1376static inline void get_pretty_name(int is_func, const char** name, const char** name_p)
1377{
1378	switch (is_func) {
1379	case 0:	*name = "variable"; *name_p = ""; break;
1380	case 1:	*name = "function"; *name_p = "()"; break;
1381	default: *name = "(unknown reference)"; *name_p = ""; break;
1382	}
1383}
1384
1385/*
1386 * Print a warning about a section mismatch.
1387 * Try to find symbols near it so user can find it.
1388 * Check whitelist before warning - it may be a false positive.
1389 */
1390static void report_sec_mismatch(const char *modname,
1391				const struct sectioncheck *mismatch,
1392				const char *fromsec,
1393				unsigned long long fromaddr,
1394				const char *fromsym,
1395				int from_is_func,
1396				const char *tosec, const char *tosym,
1397				int to_is_func)
1398{
1399	const char *from, *from_p;
1400	const char *to, *to_p;
1401	char *prl_from;
1402	char *prl_to;
1403
1404	sec_mismatch_count++;
1405	if (!sec_mismatch_verbose)
1406		return;
1407
1408	get_pretty_name(from_is_func, &from, &from_p);
1409	get_pretty_name(to_is_func, &to, &to_p);
1410
1411	warn("%s(%s+0x%llx): Section mismatch in reference from the %s %s%s "
1412	     "to the %s %s:%s%s\n",
1413	     modname, fromsec, fromaddr, from, fromsym, from_p, to, tosec,
1414	     tosym, to_p);
1415
1416	switch (mismatch->mismatch) {
1417	case TEXT_TO_ANY_INIT:
1418		prl_from = sec2annotation(fromsec);
1419		prl_to = sec2annotation(tosec);
1420		fprintf(stderr,
1421		"The function %s%s() references\n"
1422		"the %s %s%s%s.\n"
1423		"This is often because %s lacks a %s\n"
1424		"annotation or the annotation of %s is wrong.\n",
1425		prl_from, fromsym,
1426		to, prl_to, tosym, to_p,
1427		fromsym, prl_to, tosym);
1428		free(prl_from);
1429		free(prl_to);
1430		break;
1431	case DATA_TO_ANY_INIT: {
1432		prl_to = sec2annotation(tosec);
1433		fprintf(stderr,
1434		"The variable %s references\n"
1435		"the %s %s%s%s\n"
1436		"If the reference is valid then annotate the\n"
1437		"variable with __init* or __refdata (see linux/init.h) "
1438		"or name the variable:\n",
1439		fromsym, to, prl_to, tosym, to_p);
1440		print_section_list(mismatch->symbol_white_list);
1441		free(prl_to);
1442		break;
1443	}
1444	case TEXT_TO_ANY_EXIT:
1445		prl_to = sec2annotation(tosec);
1446		fprintf(stderr,
1447		"The function %s() references a %s in an exit section.\n"
1448		"Often the %s %s%s has valid usage outside the exit section\n"
1449		"and the fix is to remove the %sannotation of %s.\n",
1450		fromsym, to, to, tosym, to_p, prl_to, tosym);
1451		free(prl_to);
1452		break;
1453	case DATA_TO_ANY_EXIT: {
1454		prl_to = sec2annotation(tosec);
1455		fprintf(stderr,
1456		"The variable %s references\n"
1457		"the %s %s%s%s\n"
1458		"If the reference is valid then annotate the\n"
1459		"variable with __exit* (see linux/init.h) or "
1460		"name the variable:\n",
1461		fromsym, to, prl_to, tosym, to_p);
1462		print_section_list(mismatch->symbol_white_list);
1463		free(prl_to);
1464		break;
1465	}
1466	case XXXINIT_TO_SOME_INIT:
1467	case XXXEXIT_TO_SOME_EXIT:
1468		prl_from = sec2annotation(fromsec);
1469		prl_to = sec2annotation(tosec);
1470		fprintf(stderr,
1471		"The %s %s%s%s references\n"
1472		"a %s %s%s%s.\n"
1473		"If %s is only used by %s then\n"
1474		"annotate %s with a matching annotation.\n",
1475		from, prl_from, fromsym, from_p,
1476		to, prl_to, tosym, to_p,
1477		tosym, fromsym, tosym);
1478		free(prl_from);
1479		free(prl_to);
1480		break;
1481	case ANY_INIT_TO_ANY_EXIT:
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 init function\n"
1489		"uses functionality in the exit path.\n"
1490		"The fix is often to remove the %sannotation of\n"
1491		"%s%s so it may be used outside an exit 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 ANY_EXIT_TO_ANY_INIT:
1499		prl_from = sec2annotation(fromsec);
1500		prl_to = sec2annotation(tosec);
1501		fprintf(stderr,
1502		"The %s %s%s%s references\n"
1503		"a %s %s%s%s.\n"
1504		"This is often seen when error handling "
1505		"in the exit function\n"
1506		"uses functionality in the init path.\n"
1507		"The fix is often to remove the %sannotation of\n"
1508		"%s%s so it may be used outside an init section.\n",
1509		from, prl_from, fromsym, from_p,
1510		to, prl_to, tosym, to_p,
1511		prl_to, tosym, to_p);
1512		free(prl_from);
1513		free(prl_to);
1514		break;
1515	case EXPORT_TO_INIT_EXIT:
1516		prl_to = sec2annotation(tosec);
1517		fprintf(stderr,
1518		"The symbol %s is exported and annotated %s\n"
1519		"Fix this by removing the %sannotation of %s "
1520		"or drop the export.\n",
1521		tosym, prl_to, prl_to, tosym);
1522		free(prl_to);
1523		break;
1524	case EXTABLE_TO_NON_TEXT:
1525		fatal("There's a special handler for this mismatch type, "
1526		      "we should never get here.");
1527		break;
1528	}
1529	fprintf(stderr, "\n");
1530}
1531
1532static void default_mismatch_handler(const char *modname, struct elf_info *elf,
1533				     const struct sectioncheck* const mismatch,
1534				     Elf_Rela *r, Elf_Sym *sym, const char *fromsec)
1535{
1536	const char *tosec;
1537	Elf_Sym *to;
1538	Elf_Sym *from;
1539	const char *tosym;
1540	const char *fromsym;
1541
1542	from = find_elf_symbol2(elf, r->r_offset, fromsec);
1543	fromsym = sym_name(elf, from);
1544
1545	if (!strncmp(fromsym, "reference___initcall",
1546		     sizeof("reference___initcall")-1))
1547		return;
1548
1549	tosec = sec_name(elf, get_secindex(elf, sym));
1550	to = find_elf_symbol(elf, r->r_addend, sym);
1551	tosym = sym_name(elf, to);
1552
1553	/* check whitelist - we may ignore it */
1554	if (secref_whitelist(mismatch,
1555			     fromsec, fromsym, tosec, tosym)) {
1556		report_sec_mismatch(modname, mismatch,
1557				    fromsec, r->r_offset, fromsym,
1558				    is_function(from), tosec, tosym,
1559				    is_function(to));
1560	}
1561}
1562
1563static int is_executable_section(struct elf_info* elf, unsigned int section_index)
1564{
1565	if (section_index > elf->num_sections)
1566		fatal("section_index is outside elf->num_sections!\n");
1567
1568	return ((elf->sechdrs[section_index].sh_flags & SHF_EXECINSTR) == SHF_EXECINSTR);
1569}
1570
1571/*
1572 * We rely on a gross hack in section_rel[a]() calling find_extable_entry_size()
1573 * to know the sizeof(struct exception_table_entry) for the target architecture.
1574 */
1575static unsigned int extable_entry_size = 0;
1576static void find_extable_entry_size(const char* const sec, const Elf_Rela* r)
1577{
1578	/*
1579	 * If we're currently checking the second relocation within __ex_table,
1580	 * that relocation offset tells us the offsetof(struct
1581	 * exception_table_entry, fixup) which is equal to sizeof(struct
1582	 * exception_table_entry) divided by two.  We use that to our advantage
1583	 * since there's no portable way to get that size as every architecture
1584	 * seems to go with different sized types.  Not pretty but better than
1585	 * hard-coding the size for every architecture..
1586	 */
1587	if (!extable_entry_size)
1588		extable_entry_size = r->r_offset * 2;
1589}
1590
1591static inline bool is_extable_fault_address(Elf_Rela *r)
1592{
1593	/*
1594	 * extable_entry_size is only discovered after we've handled the
1595	 * _second_ relocation in __ex_table, so only abort when we're not
1596	 * handling the first reloc and extable_entry_size is zero.
1597	 */
1598	if (r->r_offset && extable_entry_size == 0)
1599		fatal("extable_entry size hasn't been discovered!\n");
1600
1601	return ((r->r_offset == 0) ||
1602		(r->r_offset % extable_entry_size == 0));
1603}
1604
1605#define is_second_extable_reloc(Start, Cur, Sec)			\
1606	(((Cur) == (Start) + 1) && (strcmp("__ex_table", (Sec)) == 0))
1607
1608static void report_extable_warnings(const char* modname, struct elf_info* elf,
1609				    const struct sectioncheck* const mismatch,
1610				    Elf_Rela* r, Elf_Sym* sym,
1611				    const char* fromsec, const char* tosec)
1612{
1613	Elf_Sym* fromsym = find_elf_symbol2(elf, r->r_offset, fromsec);
1614	const char* fromsym_name = sym_name(elf, fromsym);
1615	Elf_Sym* tosym = find_elf_symbol(elf, r->r_addend, sym);
1616	const char* tosym_name = sym_name(elf, tosym);
1617	const char* from_pretty_name;
1618	const char* from_pretty_name_p;
1619	const char* to_pretty_name;
1620	const char* to_pretty_name_p;
1621
1622	get_pretty_name(is_function(fromsym),
1623			&from_pretty_name, &from_pretty_name_p);
1624	get_pretty_name(is_function(tosym),
1625			&to_pretty_name, &to_pretty_name_p);
1626
1627	warn("%s(%s+0x%lx): Section mismatch in reference"
1628	     " from the %s %s%s to the %s %s:%s%s\n",
1629	     modname, fromsec, (long)r->r_offset, from_pretty_name,
1630	     fromsym_name, from_pretty_name_p,
1631	     to_pretty_name, tosec, tosym_name, to_pretty_name_p);
1632
1633	if (!match(tosec, mismatch->bad_tosec) &&
1634	    is_executable_section(elf, get_secindex(elf, sym)))
1635		fprintf(stderr,
1636			"The relocation at %s+0x%lx references\n"
1637			"section \"%s\" which is not in the list of\n"
1638			"authorized sections.  If you're adding a new section\n"
1639			"and/or if this reference is valid, add \"%s\" to the\n"
1640			"list of authorized sections to jump to on fault.\n"
1641			"This can be achieved by adding \"%s\" to \n"
1642			"OTHER_TEXT_SECTIONS in scripts/mod/modpost.c.\n",
1643			fromsec, (long)r->r_offset, tosec, tosec, tosec);
1644}
1645
1646static void extable_mismatch_handler(const char* modname, struct elf_info *elf,
1647				     const struct sectioncheck* const mismatch,
1648				     Elf_Rela* r, Elf_Sym* sym,
1649				     const char *fromsec)
1650{
1651	const char* tosec = sec_name(elf, get_secindex(elf, sym));
1652
1653	sec_mismatch_count++;
1654
1655	if (sec_mismatch_verbose)
1656		report_extable_warnings(modname, elf, mismatch, r, sym,
1657					fromsec, tosec);
1658
1659	if (match(tosec, mismatch->bad_tosec))
1660		fatal("The relocation at %s+0x%lx references\n"
1661		      "section \"%s\" which is black-listed.\n"
1662		      "Something is seriously wrong and should be fixed.\n"
1663		      "You might get more information about where this is\n"
1664		      "coming from by using scripts/check_extable.sh %s\n",
1665		      fromsec, (long)r->r_offset, tosec, modname);
1666	else if (!is_executable_section(elf, get_secindex(elf, sym))) {
1667		if (is_extable_fault_address(r))
1668			fatal("The relocation at %s+0x%lx references\n"
1669			      "section \"%s\" which is not executable, IOW\n"
1670			      "it is not possible for the kernel to fault\n"
1671			      "at that address.  Something is seriously wrong\n"
1672			      "and should be fixed.\n",
1673			      fromsec, (long)r->r_offset, tosec);
1674		else
1675			fatal("The relocation at %s+0x%lx references\n"
1676			      "section \"%s\" which is not executable, IOW\n"
1677			      "the kernel will fault if it ever tries to\n"
1678			      "jump to it.  Something is seriously wrong\n"
1679			      "and should be fixed.\n",
1680			      fromsec, (long)r->r_offset, tosec);
1681	}
1682}
1683
1684static void check_section_mismatch(const char *modname, struct elf_info *elf,
1685				   Elf_Rela *r, Elf_Sym *sym, const char *fromsec)
1686{
1687	const char *tosec = sec_name(elf, get_secindex(elf, sym));
1688	const struct sectioncheck *mismatch = section_mismatch(fromsec, tosec);
1689
1690	if (mismatch) {
1691		if (mismatch->handler)
1692			mismatch->handler(modname, elf,  mismatch,
1693					  r, sym, fromsec);
1694		else
1695			default_mismatch_handler(modname, elf, mismatch,
1696						 r, sym, fromsec);
1697	}
1698}
1699
1700static unsigned int *reloc_location(struct elf_info *elf,
1701				    Elf_Shdr *sechdr, Elf_Rela *r)
1702{
1703	Elf_Shdr *sechdrs = elf->sechdrs;
1704	int section = sechdr->sh_info;
1705
1706	return (void *)elf->hdr + sechdrs[section].sh_offset +
1707		r->r_offset;
1708}
1709
1710static int addend_386_rel(struct elf_info *elf, Elf_Shdr *sechdr, Elf_Rela *r)
1711{
1712	unsigned int r_typ = ELF_R_TYPE(r->r_info);
1713	unsigned int *location = reloc_location(elf, sechdr, r);
1714
1715	switch (r_typ) {
1716	case R_386_32:
1717		r->r_addend = TO_NATIVE(*location);
1718		break;
1719	case R_386_PC32:
1720		r->r_addend = TO_NATIVE(*location) + 4;
1721		/* For CONFIG_RELOCATABLE=y */
1722		if (elf->hdr->e_type == ET_EXEC)
1723			r->r_addend += r->r_offset;
1724		break;
1725	}
1726	return 0;
1727}
1728
1729#ifndef R_ARM_CALL
1730#define R_ARM_CALL	28
1731#endif
1732#ifndef R_ARM_JUMP24
1733#define R_ARM_JUMP24	29
1734#endif
1735
1736#ifndef	R_ARM_THM_CALL
1737#define	R_ARM_THM_CALL		10
1738#endif
1739#ifndef	R_ARM_THM_JUMP24
1740#define	R_ARM_THM_JUMP24	30
1741#endif
1742#ifndef	R_ARM_THM_JUMP19
1743#define	R_ARM_THM_JUMP19	51
1744#endif
1745
1746static int addend_arm_rel(struct elf_info *elf, Elf_Shdr *sechdr, Elf_Rela *r)
1747{
1748	unsigned int r_typ = ELF_R_TYPE(r->r_info);
1749
1750	switch (r_typ) {
1751	case R_ARM_ABS32:
1752		/* From ARM ABI: (S + A) | T */
1753		r->r_addend = (int)(long)
1754			      (elf->symtab_start + ELF_R_SYM(r->r_info));
1755		break;
1756	case R_ARM_PC24:
1757	case R_ARM_CALL:
1758	case R_ARM_JUMP24:
1759	case R_ARM_THM_CALL:
1760	case R_ARM_THM_JUMP24:
1761	case R_ARM_THM_JUMP19:
1762		/* From ARM ABI: ((S + A) | T) - P */
1763		r->r_addend = (int)(long)(elf->hdr +
1764			      sechdr->sh_offset +
1765			      (r->r_offset - sechdr->sh_addr));
1766		break;
1767	default:
1768		return 1;
1769	}
1770	return 0;
1771}
1772
1773static int addend_mips_rel(struct elf_info *elf, Elf_Shdr *sechdr, Elf_Rela *r)
1774{
1775	unsigned int r_typ = ELF_R_TYPE(r->r_info);
1776	unsigned int *location = reloc_location(elf, sechdr, r);
1777	unsigned int inst;
1778
1779	if (r_typ == R_MIPS_HI16)
1780		return 1;	/* skip this */
1781	inst = TO_NATIVE(*location);
1782	switch (r_typ) {
1783	case R_MIPS_LO16:
1784		r->r_addend = inst & 0xffff;
1785		break;
1786	case R_MIPS_26:
1787		r->r_addend = (inst & 0x03ffffff) << 2;
1788		break;
1789	case R_MIPS_32:
1790		r->r_addend = inst;
1791		break;
1792	}
1793	return 0;
1794}
1795
1796static void section_rela(const char *modname, struct elf_info *elf,
1797			 Elf_Shdr *sechdr)
1798{
1799	Elf_Sym  *sym;
1800	Elf_Rela *rela;
1801	Elf_Rela r;
1802	unsigned int r_sym;
1803	const char *fromsec;
1804
1805	Elf_Rela *start = (void *)elf->hdr + sechdr->sh_offset;
1806	Elf_Rela *stop  = (void *)start + sechdr->sh_size;
1807
1808	fromsec = sech_name(elf, sechdr);
1809	fromsec += strlen(".rela");
1810	/* if from section (name) is know good then skip it */
1811	if (match(fromsec, section_white_list))
1812		return;
1813
1814	for (rela = start; rela < stop; rela++) {
1815		r.r_offset = TO_NATIVE(rela->r_offset);
1816#if KERNEL_ELFCLASS == ELFCLASS64
1817		if (elf->hdr->e_machine == EM_MIPS) {
1818			unsigned int r_typ;
1819			r_sym = ELF64_MIPS_R_SYM(rela->r_info);
1820			r_sym = TO_NATIVE(r_sym);
1821			r_typ = ELF64_MIPS_R_TYPE(rela->r_info);
1822			r.r_info = ELF64_R_INFO(r_sym, r_typ);
1823		} else {
1824			r.r_info = TO_NATIVE(rela->r_info);
1825			r_sym = ELF_R_SYM(r.r_info);
1826		}
1827#else
1828		r.r_info = TO_NATIVE(rela->r_info);
1829		r_sym = ELF_R_SYM(r.r_info);
1830#endif
1831		r.r_addend = TO_NATIVE(rela->r_addend);
1832		sym = elf->symtab_start + r_sym;
1833		/* Skip special sections */
1834		if (is_shndx_special(sym->st_shndx))
1835			continue;
1836		if (is_second_extable_reloc(start, rela, fromsec))
1837			find_extable_entry_size(fromsec, &r);
1838		check_section_mismatch(modname, elf, &r, sym, fromsec);
1839	}
1840}
1841
1842static void section_rel(const char *modname, struct elf_info *elf,
1843			Elf_Shdr *sechdr)
1844{
1845	Elf_Sym *sym;
1846	Elf_Rel *rel;
1847	Elf_Rela r;
1848	unsigned int r_sym;
1849	const char *fromsec;
1850
1851	Elf_Rel *start = (void *)elf->hdr + sechdr->sh_offset;
1852	Elf_Rel *stop  = (void *)start + sechdr->sh_size;
1853
1854	fromsec = sech_name(elf, sechdr);
1855	fromsec += strlen(".rel");
1856	/* if from section (name) is know good then skip it */
1857	if (match(fromsec, section_white_list))
1858		return;
1859
1860	for (rel = start; rel < stop; rel++) {
1861		r.r_offset = TO_NATIVE(rel->r_offset);
1862#if KERNEL_ELFCLASS == ELFCLASS64
1863		if (elf->hdr->e_machine == EM_MIPS) {
1864			unsigned int r_typ;
1865			r_sym = ELF64_MIPS_R_SYM(rel->r_info);
1866			r_sym = TO_NATIVE(r_sym);
1867			r_typ = ELF64_MIPS_R_TYPE(rel->r_info);
1868			r.r_info = ELF64_R_INFO(r_sym, r_typ);
1869		} else {
1870			r.r_info = TO_NATIVE(rel->r_info);
1871			r_sym = ELF_R_SYM(r.r_info);
1872		}
1873#else
1874		r.r_info = TO_NATIVE(rel->r_info);
1875		r_sym = ELF_R_SYM(r.r_info);
1876#endif
1877		r.r_addend = 0;
1878		switch (elf->hdr->e_machine) {
1879		case EM_386:
1880			if (addend_386_rel(elf, sechdr, &r))
1881				continue;
1882			break;
1883		case EM_ARM:
1884			if (addend_arm_rel(elf, sechdr, &r))
1885				continue;
1886			break;
1887		case EM_MIPS:
1888			if (addend_mips_rel(elf, sechdr, &r))
1889				continue;
1890			break;
1891		}
1892		sym = elf->symtab_start + r_sym;
1893		/* Skip special sections */
1894		if (is_shndx_special(sym->st_shndx))
1895			continue;
1896		if (is_second_extable_reloc(start, rel, fromsec))
1897			find_extable_entry_size(fromsec, &r);
1898		check_section_mismatch(modname, elf, &r, sym, fromsec);
1899	}
1900}
1901
1902/**
1903 * A module includes a number of sections that are discarded
1904 * either when loaded or when used as built-in.
1905 * For loaded modules all functions marked __init and all data
1906 * marked __initdata will be discarded when the module has been initialized.
1907 * Likewise for modules used built-in the sections marked __exit
1908 * are discarded because __exit marked function are supposed to be called
1909 * only when a module is unloaded which never happens for built-in modules.
1910 * The check_sec_ref() function traverses all relocation records
1911 * to find all references to a section that reference a section that will
1912 * be discarded and warns about it.
1913 **/
1914static void check_sec_ref(struct module *mod, const char *modname,
1915			  struct elf_info *elf)
1916{
1917	int i;
1918	Elf_Shdr *sechdrs = elf->sechdrs;
1919
1920	/* Walk through all sections */
1921	for (i = 0; i < elf->num_sections; i++) {
1922		check_section(modname, elf, &elf->sechdrs[i]);
1923		/* We want to process only relocation sections and not .init */
1924		if (sechdrs[i].sh_type == SHT_RELA)
1925			section_rela(modname, elf, &elf->sechdrs[i]);
1926		else if (sechdrs[i].sh_type == SHT_REL)
1927			section_rel(modname, elf, &elf->sechdrs[i]);
1928	}
1929}
1930
1931static char *remove_dot(char *s)
1932{
1933	size_t n = strcspn(s, ".");
1934
1935	if (n && s[n]) {
1936		size_t m = strspn(s + n + 1, "0123456789");
1937		if (m && (s[n + m] == '.' || s[n + m] == 0))
1938			s[n] = 0;
1939	}
1940	return s;
1941}
1942
1943static void read_symbols(char *modname)
1944{
1945	const char *symname;
1946	char *version;
1947	char *license;
 
1948	struct module *mod;
1949	struct elf_info info = { };
1950	Elf_Sym *sym;
1951
1952	if (!parse_elf(&info, modname))
1953		return;
1954
1955	mod = new_module(modname);
1956
1957	/* When there's no vmlinux, don't print warnings about
1958	 * unresolved symbols (since there'll be too many ;) */
1959	if (is_vmlinux(modname)) {
1960		have_vmlinux = 1;
1961		mod->skip = 1;
1962	}
1963
1964	license = get_modinfo(info.modinfo, info.modinfo_len, "license");
1965	if (!license && !is_vmlinux(modname))
1966		warn("modpost: missing MODULE_LICENSE() in %s\n"
1967		     "see include/linux/module.h for "
1968		     "more information\n", modname);
1969	while (license) {
1970		if (license_is_gpl_compatible(license))
1971			mod->gpl_compatible = 1;
1972		else {
1973			mod->gpl_compatible = 0;
1974			break;
1975		}
1976		license = get_next_modinfo(info.modinfo, info.modinfo_len,
1977					   "license", license);
 
 
 
 
 
1978	}
1979
1980	for (sym = info.symtab_start; sym < info.symtab_stop; sym++) {
1981		symname = remove_dot(info.strtab + sym->st_name);
1982
1983		handle_modversions(mod, &info, sym, symname);
1984		handle_moddevtable(mod, &info, sym, symname);
1985	}
1986	if (!is_vmlinux(modname) ||
1987	     (is_vmlinux(modname) && vmlinux_section_warnings))
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1988		check_sec_ref(mod, modname, &info);
1989
1990	version = get_modinfo(info.modinfo, info.modinfo_len, "version");
1991	if (version)
1992		maybe_frob_rcs_version(modname, version, info.modinfo,
1993				       version - (char *)info.hdr);
1994	if (version || (all_versions && !is_vmlinux(modname)))
1995		get_src_version(modname, mod->srcversion,
1996				sizeof(mod->srcversion)-1);
1997
1998	parse_elf_finish(&info);
1999
2000	/* Our trick to get versioning for module struct etc. - it's
2001	 * never passed as an argument to an exported function, so
2002	 * the automatic versioning doesn't pick it up, but it's really
2003	 * important anyhow */
2004	if (modversions)
2005		mod->unres = alloc_symbol("module_layout", 0, mod->unres);
2006}
2007
2008static void read_symbols_from_files(const char *filename)
2009{
2010	FILE *in = stdin;
2011	char fname[PATH_MAX];
2012
2013	if (strcmp(filename, "-") != 0) {
2014		in = fopen(filename, "r");
2015		if (!in)
2016			fatal("Can't open filenames file %s: %m", filename);
2017	}
2018
2019	while (fgets(fname, PATH_MAX, in) != NULL) {
2020		if (strends(fname, "\n"))
2021			fname[strlen(fname)-1] = '\0';
2022		read_symbols(fname);
2023	}
2024
2025	if (in != stdin)
2026		fclose(in);
2027}
2028
2029#define SZ 500
2030
2031/* We first write the generated file into memory using the
2032 * following helper, then compare to the file on disk and
2033 * only update the later if anything changed */
2034
2035void __attribute__((format(printf, 2, 3))) buf_printf(struct buffer *buf,
2036						      const char *fmt, ...)
2037{
2038	char tmp[SZ];
2039	int len;
2040	va_list ap;
2041
2042	va_start(ap, fmt);
2043	len = vsnprintf(tmp, SZ, fmt, ap);
2044	buf_write(buf, tmp, len);
2045	va_end(ap);
2046}
2047
2048void buf_write(struct buffer *buf, const char *s, int len)
2049{
2050	if (buf->size - buf->pos < len) {
2051		buf->size += len + SZ;
2052		buf->p = realloc(buf->p, buf->size);
2053	}
2054	strncpy(buf->p + buf->pos, s, len);
2055	buf->pos += len;
2056}
2057
2058static void check_for_gpl_usage(enum export exp, const char *m, const char *s)
2059{
2060	const char *e = is_vmlinux(m) ?"":".ko";
2061
2062	switch (exp) {
2063	case export_gpl:
2064		fatal("modpost: GPL-incompatible module %s%s "
2065		      "uses GPL-only symbol '%s'\n", m, e, s);
2066		break;
2067	case export_unused_gpl:
2068		fatal("modpost: GPL-incompatible module %s%s "
2069		      "uses GPL-only symbol marked UNUSED '%s'\n", m, e, s);
2070		break;
2071	case export_gpl_future:
2072		warn("modpost: GPL-incompatible module %s%s "
2073		      "uses future GPL-only symbol '%s'\n", m, e, s);
2074		break;
2075	case export_plain:
2076	case export_unused:
2077	case export_unknown:
2078		/* ignore */
2079		break;
2080	}
2081}
2082
2083static void check_for_unused(enum export exp, const char *m, const char *s)
2084{
2085	const char *e = is_vmlinux(m) ?"":".ko";
2086
2087	switch (exp) {
2088	case export_unused:
2089	case export_unused_gpl:
2090		warn("modpost: module %s%s "
2091		      "uses symbol '%s' marked UNUSED\n", m, e, s);
2092		break;
2093	default:
2094		/* ignore */
2095		break;
2096	}
2097}
2098
2099static void check_exports(struct module *mod)
2100{
2101	struct symbol *s, *exp;
 
2102
2103	for (s = mod->unres; s; s = s->next) {
2104		const char *basename;
2105		exp = find_symbol(s->name);
2106		if (!exp || exp->module == mod)
 
 
 
 
 
 
 
 
 
 
2107			continue;
 
2108		basename = strrchr(mod->name, '/');
2109		if (basename)
2110			basename++;
2111		else
2112			basename = mod->name;
 
 
 
 
 
 
 
 
 
 
 
 
2113		if (!mod->gpl_compatible)
2114			check_for_gpl_usage(exp->export, basename, exp->name);
2115		check_for_unused(exp->export, basename, exp->name);
2116	}
 
 
2117}
2118
2119static int check_modname_len(struct module *mod)
2120{
2121	const char *mod_name;
2122
2123	mod_name = strrchr(mod->name, '/');
2124	if (mod_name == NULL)
2125		mod_name = mod->name;
2126	else
2127		mod_name++;
2128	if (strlen(mod_name) >= MODULE_NAME_LEN) {
2129		merror("module name is too long [%s.ko]\n", mod->name);
2130		return 1;
2131	}
2132
2133	return 0;
2134}
2135
2136/**
2137 * Header for the generated file
2138 **/
2139static void add_header(struct buffer *b, struct module *mod)
2140{
 
2141	buf_printf(b, "#include <linux/module.h>\n");
2142	buf_printf(b, "#include <linux/vermagic.h>\n");
2143	buf_printf(b, "#include <linux/compiler.h>\n");
2144	buf_printf(b, "\n");
 
 
2145	buf_printf(b, "MODULE_INFO(vermagic, VERMAGIC_STRING);\n");
2146	buf_printf(b, "MODULE_INFO(name, KBUILD_MODNAME);\n");
2147	buf_printf(b, "\n");
2148	buf_printf(b, "__visible struct module __this_module\n");
2149	buf_printf(b, "__attribute__((section(\".gnu.linkonce.this_module\"))) = {\n");
2150	buf_printf(b, "\t.name = KBUILD_MODNAME,\n");
2151	if (mod->has_init)
2152		buf_printf(b, "\t.init = init_module,\n");
2153	if (mod->has_cleanup)
2154		buf_printf(b, "#ifdef CONFIG_MODULE_UNLOAD\n"
2155			      "\t.exit = cleanup_module,\n"
2156			      "#endif\n");
2157	buf_printf(b, "\t.arch = MODULE_ARCH_INIT,\n");
2158	buf_printf(b, "};\n");
2159}
2160
2161static void add_intree_flag(struct buffer *b, int is_intree)
2162{
2163	if (is_intree)
2164		buf_printf(b, "\nMODULE_INFO(intree, \"Y\");\n");
2165}
2166
2167/* Cannot check for assembler */
2168static void add_retpoline(struct buffer *b)
2169{
2170	buf_printf(b, "\n#ifdef RETPOLINE\n");
2171	buf_printf(b, "MODULE_INFO(retpoline, \"Y\");\n");
2172	buf_printf(b, "#endif\n");
2173}
2174
2175static void add_staging_flag(struct buffer *b, const char *name)
2176{
2177	static const char *staging_dir = "drivers/staging";
2178
2179	if (strncmp(staging_dir, name, strlen(staging_dir)) == 0)
2180		buf_printf(b, "\nMODULE_INFO(staging, \"Y\");\n");
2181}
2182
2183/**
2184 * Record CRCs for unresolved symbols
2185 **/
2186static int add_versions(struct buffer *b, struct module *mod)
2187{
2188	struct symbol *s, *exp;
2189	int err = 0;
2190
2191	for (s = mod->unres; s; s = s->next) {
2192		exp = find_symbol(s->name);
2193		if (!exp || exp->module == mod) {
2194			if (have_vmlinux && !s->weak) {
2195				if (warn_unresolved) {
2196					warn("\"%s\" [%s.ko] undefined!\n",
2197					     s->name, mod->name);
2198				} else {
2199					merror("\"%s\" [%s.ko] undefined!\n",
2200					       s->name, mod->name);
2201					err = 1;
2202				}
2203			}
2204			continue;
2205		}
2206		s->module = exp->module;
2207		s->crc_valid = exp->crc_valid;
2208		s->crc = exp->crc;
2209	}
2210
2211	if (!modversions)
2212		return err;
2213
2214	buf_printf(b, "\n");
2215	buf_printf(b, "static const struct modversion_info ____versions[]\n");
2216	buf_printf(b, "__used\n");
2217	buf_printf(b, "__attribute__((section(\"__versions\"))) = {\n");
2218
2219	for (s = mod->unres; s; s = s->next) {
2220		if (!s->module)
2221			continue;
2222		if (!s->crc_valid) {
2223			warn("\"%s\" [%s.ko] has no CRC!\n",
2224				s->name, mod->name);
2225			continue;
2226		}
2227		if (strlen(s->name) >= MODULE_NAME_LEN) {
2228			merror("too long symbol \"%s\" [%s.ko]\n",
2229			       s->name, mod->name);
2230			err = 1;
2231			break;
2232		}
2233		buf_printf(b, "\t{ %#8x, __VMLINUX_SYMBOL_STR(%s) },\n",
2234			   s->crc, s->name);
2235	}
2236
2237	buf_printf(b, "};\n");
2238
2239	return err;
2240}
2241
2242static void add_depends(struct buffer *b, struct module *mod,
2243			struct module *modules)
2244{
2245	struct symbol *s;
2246	struct module *m;
2247	int first = 1;
2248
2249	for (m = modules; m; m = m->next)
2250		m->seen = is_vmlinux(m->name);
 
 
2251
2252	buf_printf(b, "\n");
2253	buf_printf(b, "static const char __module_depends[]\n");
2254	buf_printf(b, "__used\n");
2255	buf_printf(b, "__attribute__((section(\".modinfo\"))) =\n");
2256	buf_printf(b, "\"depends=");
2257	for (s = mod->unres; s; s = s->next) {
2258		const char *p;
2259		if (!s->module)
2260			continue;
2261
2262		if (s->module->seen)
2263			continue;
2264
2265		s->module->seen = 1;
2266		p = strrchr(s->module->name, '/');
2267		if (p)
2268			p++;
2269		else
2270			p = s->module->name;
2271		buf_printf(b, "%s%s", first ? "" : ",", p);
2272		first = 0;
2273	}
2274	buf_printf(b, "\";\n");
2275}
2276
2277static void add_srcversion(struct buffer *b, struct module *mod)
2278{
2279	if (mod->srcversion[0]) {
2280		buf_printf(b, "\n");
2281		buf_printf(b, "MODULE_INFO(srcversion, \"%s\");\n",
2282			   mod->srcversion);
2283	}
2284}
2285
2286static void write_if_changed(struct buffer *b, const char *fname)
2287{
2288	char *tmp;
2289	FILE *file;
2290	struct stat st;
2291
2292	file = fopen(fname, "r");
2293	if (!file)
2294		goto write;
2295
2296	if (fstat(fileno(file), &st) < 0)
2297		goto close_write;
2298
2299	if (st.st_size != b->pos)
2300		goto close_write;
2301
2302	tmp = NOFAIL(malloc(b->pos));
2303	if (fread(tmp, 1, b->pos, file) != b->pos)
2304		goto free_write;
2305
2306	if (memcmp(tmp, b->p, b->pos) != 0)
2307		goto free_write;
2308
2309	free(tmp);
2310	fclose(file);
2311	return;
2312
2313 free_write:
2314	free(tmp);
2315 close_write:
2316	fclose(file);
2317 write:
2318	file = fopen(fname, "w");
2319	if (!file) {
2320		perror(fname);
2321		exit(1);
2322	}
2323	if (fwrite(b->p, 1, b->pos, file) != b->pos) {
2324		perror(fname);
2325		exit(1);
2326	}
2327	fclose(file);
2328}
2329
2330/* parse Module.symvers file. line format:
2331 * 0x12345678<tab>symbol<tab>module[[<tab>export]<tab>something]
2332 **/
2333static void read_dump(const char *fname, unsigned int kernel)
2334{
2335	unsigned long size, pos = 0;
2336	void *file = grab_file(fname, &size);
2337	char *line;
2338
2339	if (!file)
2340		/* No symbol versions, silently ignore */
2341		return;
2342
2343	while ((line = get_next_line(&pos, file, size))) {
2344		char *symname, *modname, *d, *export, *end;
2345		unsigned int crc;
2346		struct module *mod;
2347		struct symbol *s;
2348
2349		if (!(symname = strchr(line, '\t')))
2350			goto fail;
2351		*symname++ = '\0';
2352		if (!(modname = strchr(symname, '\t')))
 
 
 
2353			goto fail;
2354		*modname++ = '\0';
2355		if ((export = strchr(modname, '\t')) != NULL)
2356			*export++ = '\0';
2357		if (export && ((end = strchr(export, '\t')) != NULL))
2358			*end = '\0';
2359		crc = strtoul(line, &d, 16);
2360		if (*symname == '\0' || *modname == '\0' || *d != '\0')
2361			goto fail;
2362		mod = find_module(modname);
2363		if (!mod) {
2364			if (is_vmlinux(modname))
2365				have_vmlinux = 1;
2366			mod = new_module(modname);
2367			mod->skip = 1;
2368		}
2369		s = sym_add_exported(symname, mod, export_no(export));
2370		s->kernel    = kernel;
2371		s->preloaded = 1;
 
2372		sym_update_crc(symname, mod, crc, export_no(export));
 
2373	}
2374	release_file(file, size);
2375	return;
2376fail:
2377	release_file(file, size);
2378	fatal("parse error in symbol dump file\n");
2379}
2380
2381/* For normal builds always dump all symbols.
2382 * For external modules only dump symbols
2383 * that are not read from kernel Module.symvers.
2384 **/
2385static int dump_sym(struct symbol *sym)
2386{
2387	if (!external_module)
2388		return 1;
2389	if (sym->vmlinux || sym->kernel)
2390		return 0;
2391	return 1;
2392}
2393
2394static void write_dump(const char *fname)
2395{
2396	struct buffer buf = { };
2397	struct symbol *symbol;
 
2398	int n;
2399
2400	for (n = 0; n < SYMBOL_HASH_SIZE ; n++) {
2401		symbol = symbolhash[n];
2402		while (symbol) {
2403			if (dump_sym(symbol))
2404				buf_printf(&buf, "0x%08x\t%s\t%s\t%s\n",
2405					symbol->crc, symbol->name,
2406					symbol->module->name,
2407					export_str(symbol->export));
 
 
 
2408			symbol = symbol->next;
2409		}
2410	}
2411	write_if_changed(&buf, fname);
2412	free(buf.p);
2413}
2414
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
2415struct ext_sym_list {
2416	struct ext_sym_list *next;
2417	const char *file;
2418};
2419
2420int main(int argc, char **argv)
2421{
2422	struct module *mod;
2423	struct buffer buf = { };
2424	char *kernel_read = NULL, *module_read = NULL;
2425	char *dump_write = NULL, *files_source = NULL;
2426	int opt;
2427	int err;
 
2428	struct ext_sym_list *extsym_iter;
2429	struct ext_sym_list *extsym_start = NULL;
2430
2431	while ((opt = getopt(argc, argv, "i:I:e:mnsST:o:awM:K:E")) != -1) {
2432		switch (opt) {
2433		case 'i':
2434			kernel_read = optarg;
2435			break;
2436		case 'I':
2437			module_read = optarg;
2438			external_module = 1;
2439			break;
2440		case 'e':
2441			external_module = 1;
2442			extsym_iter =
2443			   NOFAIL(malloc(sizeof(*extsym_iter)));
2444			extsym_iter->next = extsym_start;
2445			extsym_iter->file = optarg;
2446			extsym_start = extsym_iter;
2447			break;
2448		case 'm':
2449			modversions = 1;
2450			break;
2451		case 'n':
2452			ignore_missing_files = 1;
2453			break;
2454		case 'o':
2455			dump_write = optarg;
2456			break;
2457		case 'a':
2458			all_versions = 1;
2459			break;
2460		case 's':
2461			vmlinux_section_warnings = 0;
2462			break;
2463		case 'S':
2464			sec_mismatch_verbose = 0;
2465			break;
2466		case 'T':
2467			files_source = optarg;
2468			break;
2469		case 'w':
2470			warn_unresolved = 1;
2471			break;
2472		case 'E':
2473			sec_mismatch_fatal = 1;
2474			break;
 
 
 
2475		default:
2476			exit(1);
2477		}
2478	}
2479
2480	if (kernel_read)
2481		read_dump(kernel_read, 1);
2482	if (module_read)
2483		read_dump(module_read, 0);
2484	while (extsym_start) {
2485		read_dump(extsym_start->file, 0);
2486		extsym_iter = extsym_start->next;
2487		free(extsym_start);
2488		extsym_start = extsym_iter;
2489	}
2490
2491	while (optind < argc)
2492		read_symbols(argv[optind++]);
2493
2494	if (files_source)
2495		read_symbols_from_files(files_source);
2496
2497	for (mod = modules; mod; mod = mod->next) {
2498		if (mod->skip)
2499			continue;
2500		check_exports(mod);
2501	}
2502
2503	err = 0;
2504
2505	for (mod = modules; mod; mod = mod->next) {
2506		char fname[PATH_MAX];
2507
2508		if (mod->skip)
2509			continue;
2510
2511		buf.pos = 0;
2512
2513		err |= check_modname_len(mod);
 
 
 
 
2514		add_header(&buf, mod);
2515		add_intree_flag(&buf, !external_module);
2516		add_retpoline(&buf);
2517		add_staging_flag(&buf, mod->name);
2518		err |= add_versions(&buf, mod);
2519		add_depends(&buf, mod, modules);
2520		add_moddevtable(&buf, mod);
2521		add_srcversion(&buf, mod);
2522
2523		sprintf(fname, "%s.mod.c", mod->name);
2524		write_if_changed(&buf, fname);
2525	}
 
 
 
 
 
 
2526	if (dump_write)
2527		write_dump(dump_write);
2528	if (sec_mismatch_count) {
2529		if (!sec_mismatch_verbose) {
2530			warn("modpost: Found %d section mismatch(es).\n"
2531			     "To see full details build your kernel with:\n"
2532			     "'make CONFIG_DEBUG_SECTION_MISMATCH=y'\n",
2533			     sec_mismatch_count);
2534		}
2535		if (sec_mismatch_fatal) {
2536			fatal("modpost: Section mismatches detected.\n"
2537			      "Set CONFIG_SECTION_MISMATCH_WARN_ONLY=y to allow them.\n");
 
 
 
 
 
 
 
 
2538		}
2539	}
 
2540	free(buf.p);
2541
2542	return err;
2543}