PageRenderTime 150ms CodeModel.GetById 25ms app.highlight 109ms RepoModel.GetById 2ms app.codeStats 0ms

/scripts/mod/modpost.c

http://github.com/mirrors/linux
C | 2681 lines | 2035 code | 313 blank | 333 comment | 449 complexity | 3d309a0628041c8314a98ef5ab3849a3 MD5 | raw file

Large files files are truncated, but you can click here to view the full file

   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 <elf.h>
  16#include <stdio.h>
  17#include <ctype.h>
  18#include <string.h>
  19#include <limits.h>
  20#include <stdbool.h>
  21#include <errno.h>
  22#include "modpost.h"
  23#include "../../include/linux/license.h"
  24
  25/* Are we using CONFIG_MODVERSIONS? */
  26static int modversions = 0;
  27/* Warn about undefined symbols? (do so if we have vmlinux) */
  28static int have_vmlinux = 0;
  29/* Is CONFIG_MODULE_SRCVERSION_ALL set? */
  30static int all_versions = 0;
  31/* If we are modposting external module set to 1 */
  32static int external_module = 0;
  33/* Warn about section mismatch in vmlinux if set to 1 */
  34static int vmlinux_section_warnings = 1;
  35/* Only warn about unresolved symbols */
  36static int warn_unresolved = 0;
  37/* How a symbol is exported */
  38static int sec_mismatch_count = 0;
  39static int sec_mismatch_fatal = 0;
  40/* ignore missing files */
  41static int ignore_missing_files;
  42/* If set to 1, only warn (instead of error) about missing ns imports */
  43static int allow_missing_ns_imports;
  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
  56void __attribute__((format(printf, 2, 3)))
  57modpost_log(enum loglevel loglevel, const char *fmt, ...)
  58{
  59	va_list arglist;
  60
  61	switch (loglevel) {
  62	case LOG_WARN:
  63		fprintf(stderr, "WARNING: ");
  64		break;
  65	case LOG_ERROR:
  66		fprintf(stderr, "ERROR: ");
  67		break;
  68	case LOG_FATAL:
  69		fprintf(stderr, "FATAL: ");
  70		break;
  71	default: /* invalid loglevel, ignore */
  72		break;
  73	}
  74
  75	fprintf(stderr, "modpost: ");
  76
  77	va_start(arglist, fmt);
  78	vfprintf(stderr, fmt, arglist);
  79	va_end(arglist);
  80
  81	if (loglevel == LOG_FATAL)
  82		exit(1);
  83}
  84
  85static inline bool strends(const char *str, const char *postfix)
  86{
  87	if (strlen(str) < strlen(postfix))
  88		return false;
  89
  90	return strcmp(str + strlen(str) - strlen(postfix), postfix) == 0;
  91}
  92
  93static int is_vmlinux(const char *modname)
  94{
  95	const char *myname;
  96
  97	myname = strrchr(modname, '/');
  98	if (myname)
  99		myname++;
 100	else
 101		myname = modname;
 102
 103	return (strcmp(myname, "vmlinux") == 0) ||
 104	       (strcmp(myname, "vmlinux.o") == 0);
 105}
 106
 107void *do_nofail(void *ptr, const char *expr)
 108{
 109	if (!ptr)
 110		fatal("Memory allocation failure: %s.\n", expr);
 111
 112	return ptr;
 113}
 114
 115/* A list of all modules we processed */
 116static struct module *modules;
 117
 118static struct module *find_module(const char *modname)
 119{
 120	struct module *mod;
 121
 122	for (mod = modules; mod; mod = mod->next)
 123		if (strcmp(mod->name, modname) == 0)
 124			break;
 125	return mod;
 126}
 127
 128static struct module *new_module(const char *modname)
 129{
 130	struct module *mod;
 131	char *p;
 132
 133	mod = NOFAIL(malloc(sizeof(*mod)));
 134	memset(mod, 0, sizeof(*mod));
 135	p = NOFAIL(strdup(modname));
 136
 137	/* strip trailing .o */
 138	if (strends(p, ".o")) {
 139		p[strlen(p) - 2] = '\0';
 140		mod->is_dot_o = 1;
 141	}
 142
 143	/* add to list */
 144	mod->name = p;
 145	mod->gpl_compatible = -1;
 146	mod->next = modules;
 147	modules = mod;
 148
 149	return mod;
 150}
 151
 152/* A hash of all exported symbols,
 153 * struct symbol is also used for lists of unresolved symbols */
 154
 155#define SYMBOL_HASH_SIZE 1024
 156
 157struct symbol {
 158	struct symbol *next;
 159	struct module *module;
 160	unsigned int crc;
 161	int crc_valid;
 162	char *namespace;
 163	unsigned int weak:1;
 164	unsigned int vmlinux:1;    /* 1 if symbol is defined in vmlinux */
 165	unsigned int kernel:1;     /* 1 if symbol is from kernel
 166				    *  (only for external modules) **/
 167	unsigned int is_static:1;  /* 1 if symbol is not global */
 168	enum export  export;       /* Type of export */
 169	char name[0];
 170};
 171
 172static struct symbol *symbolhash[SYMBOL_HASH_SIZE];
 173
 174/* This is based on the hash agorithm from gdbm, via tdb */
 175static inline unsigned int tdb_hash(const char *name)
 176{
 177	unsigned value;	/* Used to compute the hash value.  */
 178	unsigned   i;	/* Used to cycle through random values. */
 179
 180	/* Set the initial value from the key size. */
 181	for (value = 0x238F13AF * strlen(name), i = 0; name[i]; i++)
 182		value = (value + (((unsigned char *)name)[i] << (i*5 % 24)));
 183
 184	return (1103515243 * value + 12345);
 185}
 186
 187/**
 188 * Allocate a new symbols for use in the hash of exported symbols or
 189 * the list of unresolved symbols per module
 190 **/
 191static struct symbol *alloc_symbol(const char *name, unsigned int weak,
 192				   struct symbol *next)
 193{
 194	struct symbol *s = NOFAIL(malloc(sizeof(*s) + strlen(name) + 1));
 195
 196	memset(s, 0, sizeof(*s));
 197	strcpy(s->name, name);
 198	s->weak = weak;
 199	s->next = next;
 200	s->is_static = 1;
 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
 210	hash = tdb_hash(name) % SYMBOL_HASH_SIZE;
 211	symbolhash[hash] = alloc_symbol(name, 0, symbolhash[hash]);
 212
 213	return symbolhash[hash];
 214}
 215
 216static struct symbol *find_symbol(const char *name)
 217{
 218	struct symbol *s;
 219
 220	/* For our purposes, .foo matches foo.  PPC64 needs this. */
 221	if (name[0] == '.')
 222		name++;
 223
 224	for (s = symbolhash[tdb_hash(name) % SYMBOL_HASH_SIZE]; s; s = s->next) {
 225		if (strcmp(s->name, name) == 0)
 226			return s;
 227	}
 228	return NULL;
 229}
 230
 231static bool contains_namespace(struct namespace_list *list,
 232			       const char *namespace)
 233{
 234	for (; list; list = list->next)
 235		if (!strcmp(list->namespace, namespace))
 236			return true;
 237
 238	return false;
 239}
 240
 241static void add_namespace(struct namespace_list **list, const char *namespace)
 242{
 243	struct namespace_list *ns_entry;
 244
 245	if (!contains_namespace(*list, namespace)) {
 246		ns_entry = NOFAIL(malloc(sizeof(struct namespace_list) +
 247					 strlen(namespace) + 1));
 248		strcpy(ns_entry->namespace, namespace);
 249		ns_entry->next = *list;
 250		*list = ns_entry;
 251	}
 252}
 253
 254static bool module_imports_namespace(struct module *module,
 255				     const char *namespace)
 256{
 257	return contains_namespace(module->imported_namespaces, namespace);
 258}
 259
 260static const struct {
 261	const char *str;
 262	enum export export;
 263} export_list[] = {
 264	{ .str = "EXPORT_SYMBOL",            .export = export_plain },
 265	{ .str = "EXPORT_UNUSED_SYMBOL",     .export = export_unused },
 266	{ .str = "EXPORT_SYMBOL_GPL",        .export = export_gpl },
 267	{ .str = "EXPORT_UNUSED_SYMBOL_GPL", .export = export_unused_gpl },
 268	{ .str = "EXPORT_SYMBOL_GPL_FUTURE", .export = export_gpl_future },
 269	{ .str = "(unknown)",                .export = export_unknown },
 270};
 271
 272
 273static const char *export_str(enum export ex)
 274{
 275	return export_list[ex].str;
 276}
 277
 278static enum export export_no(const char *s)
 279{
 280	int i;
 281
 282	if (!s)
 283		return export_unknown;
 284	for (i = 0; export_list[i].export != export_unknown; i++) {
 285		if (strcmp(export_list[i].str, s) == 0)
 286			return export_list[i].export;
 287	}
 288	return export_unknown;
 289}
 290
 291static const char *sech_name(struct elf_info *elf, Elf_Shdr *sechdr)
 292{
 293	return (void *)elf->hdr +
 294		elf->sechdrs[elf->secindex_strings].sh_offset +
 295		sechdr->sh_name;
 296}
 297
 298static const char *sec_name(struct elf_info *elf, int secindex)
 299{
 300	return sech_name(elf, &elf->sechdrs[secindex]);
 301}
 302
 303static void *sym_get_data(const struct elf_info *info, const Elf_Sym *sym)
 304{
 305	unsigned int secindex = get_secindex(info, sym);
 306	Elf_Shdr *sechdr = &info->sechdrs[secindex];
 307	unsigned long offset;
 308
 309	offset = sym->st_value;
 310	if (info->hdr->e_type != ET_REL)
 311		offset -= sechdr->sh_addr;
 312
 313	return (void *)info->hdr + sechdr->sh_offset + offset;
 314}
 315
 316#define strstarts(str, prefix) (strncmp(str, prefix, strlen(prefix)) == 0)
 317
 318static enum export export_from_secname(struct elf_info *elf, unsigned int sec)
 319{
 320	const char *secname = sec_name(elf, sec);
 321
 322	if (strstarts(secname, "___ksymtab+"))
 323		return export_plain;
 324	else if (strstarts(secname, "___ksymtab_unused+"))
 325		return export_unused;
 326	else if (strstarts(secname, "___ksymtab_gpl+"))
 327		return export_gpl;
 328	else if (strstarts(secname, "___ksymtab_unused_gpl+"))
 329		return export_unused_gpl;
 330	else if (strstarts(secname, "___ksymtab_gpl_future+"))
 331		return export_gpl_future;
 332	else
 333		return export_unknown;
 334}
 335
 336static enum export export_from_sec(struct elf_info *elf, unsigned int sec)
 337{
 338	if (sec == elf->export_sec)
 339		return export_plain;
 340	else if (sec == elf->export_unused_sec)
 341		return export_unused;
 342	else if (sec == elf->export_gpl_sec)
 343		return export_gpl;
 344	else if (sec == elf->export_unused_gpl_sec)
 345		return export_unused_gpl;
 346	else if (sec == elf->export_gpl_future_sec)
 347		return export_gpl_future;
 348	else
 349		return export_unknown;
 350}
 351
 352static const char *namespace_from_kstrtabns(const struct elf_info *info,
 353					    const Elf_Sym *sym)
 354{
 355	const char *value = sym_get_data(info, sym);
 356	return value[0] ? value : NULL;
 357}
 358
 359static void sym_update_namespace(const char *symname, const char *namespace)
 360{
 361	struct symbol *s = find_symbol(symname);
 362
 363	/*
 364	 * That symbol should have been created earlier and thus this is
 365	 * actually an assertion.
 366	 */
 367	if (!s) {
 368		merror("Could not update namespace(%s) for symbol %s\n",
 369		       namespace, symname);
 370		return;
 371	}
 372
 373	free(s->namespace);
 374	s->namespace =
 375		namespace && namespace[0] ? NOFAIL(strdup(namespace)) : NULL;
 376}
 377
 378/**
 379 * Add an exported symbol - it may have already been added without a
 380 * CRC, in this case just update the CRC
 381 **/
 382static struct symbol *sym_add_exported(const char *name, struct module *mod,
 383				       enum export export)
 384{
 385	struct symbol *s = find_symbol(name);
 386
 387	if (!s) {
 388		s = new_symbol(name, mod, export);
 389	} else if (!external_module || is_vmlinux(s->module->name) ||
 390		   s->module == mod) {
 391		warn("%s: '%s' exported twice. Previous export was in %s%s\n",
 392		     mod->name, name, s->module->name,
 393		     is_vmlinux(s->module->name) ? "" : ".ko");
 394		return s;
 395	}
 396
 397	s->module = mod;
 398	s->vmlinux   = is_vmlinux(mod->name);
 399	s->kernel    = 0;
 400	s->export    = export;
 401	return s;
 402}
 403
 404static void sym_set_crc(const char *name, unsigned int crc)
 405{
 406	struct symbol *s = find_symbol(name);
 407
 408	/*
 409	 * Ignore stand-alone __crc_*, which might be auto-generated symbols
 410	 * such as __*_veneer in ARM ELF.
 411	 */
 412	if (!s)
 413		return;
 414
 415	s->crc = crc;
 416	s->crc_valid = 1;
 417}
 418
 419void *grab_file(const char *filename, unsigned long *size)
 420{
 421	struct stat st;
 422	void *map = MAP_FAILED;
 423	int fd;
 424
 425	fd = open(filename, O_RDONLY);
 426	if (fd < 0)
 427		return NULL;
 428	if (fstat(fd, &st))
 429		goto failed;
 430
 431	*size = st.st_size;
 432	map = mmap(NULL, *size, PROT_READ|PROT_WRITE, MAP_PRIVATE, fd, 0);
 433
 434failed:
 435	close(fd);
 436	if (map == MAP_FAILED)
 437		return NULL;
 438	return map;
 439}
 440
 441/**
 442  * Return a copy of the next line in a mmap'ed file.
 443  * spaces in the beginning of the line is trimmed away.
 444  * Return a pointer to a static buffer.
 445  **/
 446char *get_next_line(unsigned long *pos, void *file, unsigned long size)
 447{
 448	static char line[4096];
 449	int skip = 1;
 450	size_t len = 0;
 451	signed char *p = (signed char *)file + *pos;
 452	char *s = line;
 453
 454	for (; *pos < size ; (*pos)++) {
 455		if (skip && isspace(*p)) {
 456			p++;
 457			continue;
 458		}
 459		skip = 0;
 460		if (*p != '\n' && (*pos < size)) {
 461			len++;
 462			*s++ = *p++;
 463			if (len > 4095)
 464				break; /* Too long, stop */
 465		} else {
 466			/* End of string */
 467			*s = '\0';
 468			return line;
 469		}
 470	}
 471	/* End of buffer */
 472	return NULL;
 473}
 474
 475void release_file(void *file, unsigned long size)
 476{
 477	munmap(file, size);
 478}
 479
 480static int parse_elf(struct elf_info *info, const char *filename)
 481{
 482	unsigned int i;
 483	Elf_Ehdr *hdr;
 484	Elf_Shdr *sechdrs;
 485	Elf_Sym  *sym;
 486	const char *secstrings;
 487	unsigned int symtab_idx = ~0U, symtab_shndx_idx = ~0U;
 488
 489	hdr = grab_file(filename, &info->size);
 490	if (!hdr) {
 491		if (ignore_missing_files) {
 492			fprintf(stderr, "%s: %s (ignored)\n", filename,
 493				strerror(errno));
 494			return 0;
 495		}
 496		perror(filename);
 497		exit(1);
 498	}
 499	info->hdr = hdr;
 500	if (info->size < sizeof(*hdr)) {
 501		/* file too small, assume this is an empty .o file */
 502		return 0;
 503	}
 504	/* Is this a valid ELF file? */
 505	if ((hdr->e_ident[EI_MAG0] != ELFMAG0) ||
 506	    (hdr->e_ident[EI_MAG1] != ELFMAG1) ||
 507	    (hdr->e_ident[EI_MAG2] != ELFMAG2) ||
 508	    (hdr->e_ident[EI_MAG3] != ELFMAG3)) {
 509		/* Not an ELF file - silently ignore it */
 510		return 0;
 511	}
 512	/* Fix endianness in ELF header */
 513	hdr->e_type      = TO_NATIVE(hdr->e_type);
 514	hdr->e_machine   = TO_NATIVE(hdr->e_machine);
 515	hdr->e_version   = TO_NATIVE(hdr->e_version);
 516	hdr->e_entry     = TO_NATIVE(hdr->e_entry);
 517	hdr->e_phoff     = TO_NATIVE(hdr->e_phoff);
 518	hdr->e_shoff     = TO_NATIVE(hdr->e_shoff);
 519	hdr->e_flags     = TO_NATIVE(hdr->e_flags);
 520	hdr->e_ehsize    = TO_NATIVE(hdr->e_ehsize);
 521	hdr->e_phentsize = TO_NATIVE(hdr->e_phentsize);
 522	hdr->e_phnum     = TO_NATIVE(hdr->e_phnum);
 523	hdr->e_shentsize = TO_NATIVE(hdr->e_shentsize);
 524	hdr->e_shnum     = TO_NATIVE(hdr->e_shnum);
 525	hdr->e_shstrndx  = TO_NATIVE(hdr->e_shstrndx);
 526	sechdrs = (void *)hdr + hdr->e_shoff;
 527	info->sechdrs = sechdrs;
 528
 529	/* Check if file offset is correct */
 530	if (hdr->e_shoff > info->size) {
 531		fatal("section header offset=%lu in file '%s' is bigger than "
 532		      "filesize=%lu\n", (unsigned long)hdr->e_shoff,
 533		      filename, info->size);
 534		return 0;
 535	}
 536
 537	if (hdr->e_shnum == SHN_UNDEF) {
 538		/*
 539		 * There are more than 64k sections,
 540		 * read count from .sh_size.
 541		 */
 542		info->num_sections = TO_NATIVE(sechdrs[0].sh_size);
 543	}
 544	else {
 545		info->num_sections = hdr->e_shnum;
 546	}
 547	if (hdr->e_shstrndx == SHN_XINDEX) {
 548		info->secindex_strings = TO_NATIVE(sechdrs[0].sh_link);
 549	}
 550	else {
 551		info->secindex_strings = hdr->e_shstrndx;
 552	}
 553
 554	/* Fix endianness in section headers */
 555	for (i = 0; i < info->num_sections; i++) {
 556		sechdrs[i].sh_name      = TO_NATIVE(sechdrs[i].sh_name);
 557		sechdrs[i].sh_type      = TO_NATIVE(sechdrs[i].sh_type);
 558		sechdrs[i].sh_flags     = TO_NATIVE(sechdrs[i].sh_flags);
 559		sechdrs[i].sh_addr      = TO_NATIVE(sechdrs[i].sh_addr);
 560		sechdrs[i].sh_offset    = TO_NATIVE(sechdrs[i].sh_offset);
 561		sechdrs[i].sh_size      = TO_NATIVE(sechdrs[i].sh_size);
 562		sechdrs[i].sh_link      = TO_NATIVE(sechdrs[i].sh_link);
 563		sechdrs[i].sh_info      = TO_NATIVE(sechdrs[i].sh_info);
 564		sechdrs[i].sh_addralign = TO_NATIVE(sechdrs[i].sh_addralign);
 565		sechdrs[i].sh_entsize   = TO_NATIVE(sechdrs[i].sh_entsize);
 566	}
 567	/* Find symbol table. */
 568	secstrings = (void *)hdr + sechdrs[info->secindex_strings].sh_offset;
 569	for (i = 1; i < info->num_sections; i++) {
 570		const char *secname;
 571		int nobits = sechdrs[i].sh_type == SHT_NOBITS;
 572
 573		if (!nobits && sechdrs[i].sh_offset > info->size) {
 574			fatal("%s is truncated. sechdrs[i].sh_offset=%lu > "
 575			      "sizeof(*hrd)=%zu\n", filename,
 576			      (unsigned long)sechdrs[i].sh_offset,
 577			      sizeof(*hdr));
 578			return 0;
 579		}
 580		secname = secstrings + sechdrs[i].sh_name;
 581		if (strcmp(secname, ".modinfo") == 0) {
 582			if (nobits)
 583				fatal("%s has NOBITS .modinfo\n", filename);
 584			info->modinfo = (void *)hdr + sechdrs[i].sh_offset;
 585			info->modinfo_len = sechdrs[i].sh_size;
 586		} else if (strcmp(secname, "__ksymtab") == 0)
 587			info->export_sec = i;
 588		else if (strcmp(secname, "__ksymtab_unused") == 0)
 589			info->export_unused_sec = i;
 590		else if (strcmp(secname, "__ksymtab_gpl") == 0)
 591			info->export_gpl_sec = i;
 592		else if (strcmp(secname, "__ksymtab_unused_gpl") == 0)
 593			info->export_unused_gpl_sec = i;
 594		else if (strcmp(secname, "__ksymtab_gpl_future") == 0)
 595			info->export_gpl_future_sec = i;
 596
 597		if (sechdrs[i].sh_type == SHT_SYMTAB) {
 598			unsigned int sh_link_idx;
 599			symtab_idx = i;
 600			info->symtab_start = (void *)hdr +
 601			    sechdrs[i].sh_offset;
 602			info->symtab_stop  = (void *)hdr +
 603			    sechdrs[i].sh_offset + sechdrs[i].sh_size;
 604			sh_link_idx = sechdrs[i].sh_link;
 605			info->strtab       = (void *)hdr +
 606			    sechdrs[sh_link_idx].sh_offset;
 607		}
 608
 609		/* 32bit section no. table? ("more than 64k sections") */
 610		if (sechdrs[i].sh_type == SHT_SYMTAB_SHNDX) {
 611			symtab_shndx_idx = i;
 612			info->symtab_shndx_start = (void *)hdr +
 613			    sechdrs[i].sh_offset;
 614			info->symtab_shndx_stop  = (void *)hdr +
 615			    sechdrs[i].sh_offset + sechdrs[i].sh_size;
 616		}
 617	}
 618	if (!info->symtab_start)
 619		fatal("%s has no symtab?\n", filename);
 620
 621	/* Fix endianness in symbols */
 622	for (sym = info->symtab_start; sym < info->symtab_stop; sym++) {
 623		sym->st_shndx = TO_NATIVE(sym->st_shndx);
 624		sym->st_name  = TO_NATIVE(sym->st_name);
 625		sym->st_value = TO_NATIVE(sym->st_value);
 626		sym->st_size  = TO_NATIVE(sym->st_size);
 627	}
 628
 629	if (symtab_shndx_idx != ~0U) {
 630		Elf32_Word *p;
 631		if (symtab_idx != sechdrs[symtab_shndx_idx].sh_link)
 632			fatal("%s: SYMTAB_SHNDX has bad sh_link: %u!=%u\n",
 633			      filename, sechdrs[symtab_shndx_idx].sh_link,
 634			      symtab_idx);
 635		/* Fix endianness */
 636		for (p = info->symtab_shndx_start; p < info->symtab_shndx_stop;
 637		     p++)
 638			*p = TO_NATIVE(*p);
 639	}
 640
 641	return 1;
 642}
 643
 644static void parse_elf_finish(struct elf_info *info)
 645{
 646	release_file(info->hdr, info->size);
 647}
 648
 649static int ignore_undef_symbol(struct elf_info *info, const char *symname)
 650{
 651	/* ignore __this_module, it will be resolved shortly */
 652	if (strcmp(symname, "__this_module") == 0)
 653		return 1;
 654	/* ignore global offset table */
 655	if (strcmp(symname, "_GLOBAL_OFFSET_TABLE_") == 0)
 656		return 1;
 657	if (info->hdr->e_machine == EM_PPC)
 658		/* Special register function linked on all modules during final link of .ko */
 659		if (strstarts(symname, "_restgpr_") ||
 660		    strstarts(symname, "_savegpr_") ||
 661		    strstarts(symname, "_rest32gpr_") ||
 662		    strstarts(symname, "_save32gpr_") ||
 663		    strstarts(symname, "_restvr_") ||
 664		    strstarts(symname, "_savevr_"))
 665			return 1;
 666	if (info->hdr->e_machine == EM_PPC64)
 667		/* Special register function linked on all modules during final link of .ko */
 668		if (strstarts(symname, "_restgpr0_") ||
 669		    strstarts(symname, "_savegpr0_") ||
 670		    strstarts(symname, "_restvr_") ||
 671		    strstarts(symname, "_savevr_") ||
 672		    strcmp(symname, ".TOC.") == 0)
 673			return 1;
 674	/* Do not ignore this symbol */
 675	return 0;
 676}
 677
 678static void handle_modversion(const struct module *mod,
 679			      const struct elf_info *info,
 680			      const Elf_Sym *sym, const char *symname)
 681{
 682	unsigned int crc;
 683
 684	if (sym->st_shndx == SHN_UNDEF) {
 685		warn("EXPORT symbol \"%s\" [%s%s] version generation failed, symbol will not be versioned.\n",
 686		     symname, mod->name, is_vmlinux(mod->name) ? "":".ko");
 687		return;
 688	}
 689
 690	if (sym->st_shndx == SHN_ABS) {
 691		crc = sym->st_value;
 692	} else {
 693		unsigned int *crcp;
 694
 695		/* symbol points to the CRC in the ELF object */
 696		crcp = sym_get_data(info, sym);
 697		crc = TO_NATIVE(*crcp);
 698	}
 699	sym_set_crc(symname, crc);
 700}
 701
 702static void handle_symbol(struct module *mod, struct elf_info *info,
 703			  const Elf_Sym *sym, const char *symname)
 704{
 705	enum export export;
 706	const char *name;
 707
 708	if ((!is_vmlinux(mod->name) || mod->is_dot_o) &&
 709	    strstarts(symname, "__ksymtab"))
 710		export = export_from_secname(info, get_secindex(info, sym));
 711	else
 712		export = export_from_sec(info, get_secindex(info, sym));
 713
 714	switch (sym->st_shndx) {
 715	case SHN_COMMON:
 716		if (strstarts(symname, "__gnu_lto_")) {
 717			/* Should warn here, but modpost runs before the linker */
 718		} else
 719			warn("\"%s\" [%s] is COMMON symbol\n", symname, mod->name);
 720		break;
 721	case SHN_UNDEF:
 722		/* undefined symbol */
 723		if (ELF_ST_BIND(sym->st_info) != STB_GLOBAL &&
 724		    ELF_ST_BIND(sym->st_info) != STB_WEAK)
 725			break;
 726		if (ignore_undef_symbol(info, symname))
 727			break;
 728		if (info->hdr->e_machine == EM_SPARC ||
 729		    info->hdr->e_machine == EM_SPARCV9) {
 730			/* Ignore register directives. */
 731			if (ELF_ST_TYPE(sym->st_info) == STT_SPARC_REGISTER)
 732				break;
 733			if (symname[0] == '.') {
 734				char *munged = NOFAIL(strdup(symname));
 735				munged[0] = '_';
 736				munged[1] = toupper(munged[1]);
 737				symname = munged;
 738			}
 739		}
 740
 741		mod->unres = alloc_symbol(symname,
 742					  ELF_ST_BIND(sym->st_info) == STB_WEAK,
 743					  mod->unres);
 744		break;
 745	default:
 746		/* All exported symbols */
 747		if (strstarts(symname, "__ksymtab_")) {
 748			name = symname + strlen("__ksymtab_");
 749			sym_add_exported(name, mod, export);
 750		}
 751		if (strcmp(symname, "init_module") == 0)
 752			mod->has_init = 1;
 753		if (strcmp(symname, "cleanup_module") == 0)
 754			mod->has_cleanup = 1;
 755		break;
 756	}
 757}
 758
 759/**
 760 * Parse tag=value strings from .modinfo section
 761 **/
 762static char *next_string(char *string, unsigned long *secsize)
 763{
 764	/* Skip non-zero chars */
 765	while (string[0]) {
 766		string++;
 767		if ((*secsize)-- <= 1)
 768			return NULL;
 769	}
 770
 771	/* Skip any zero padding. */
 772	while (!string[0]) {
 773		string++;
 774		if ((*secsize)-- <= 1)
 775			return NULL;
 776	}
 777	return string;
 778}
 779
 780static char *get_next_modinfo(struct elf_info *info, const char *tag,
 781			      char *prev)
 782{
 783	char *p;
 784	unsigned int taglen = strlen(tag);
 785	char *modinfo = info->modinfo;
 786	unsigned long size = info->modinfo_len;
 787
 788	if (prev) {
 789		size -= prev - modinfo;
 790		modinfo = next_string(prev, &size);
 791	}
 792
 793	for (p = modinfo; p; p = next_string(p, &size)) {
 794		if (strncmp(p, tag, taglen) == 0 && p[taglen] == '=')
 795			return p + taglen + 1;
 796	}
 797	return NULL;
 798}
 799
 800static char *get_modinfo(struct elf_info *info, const char *tag)
 801
 802{
 803	return get_next_modinfo(info, tag, NULL);
 804}
 805
 806/**
 807 * Test if string s ends in string sub
 808 * return 0 if match
 809 **/
 810static int strrcmp(const char *s, const char *sub)
 811{
 812	int slen, sublen;
 813
 814	if (!s || !sub)
 815		return 1;
 816
 817	slen = strlen(s);
 818	sublen = strlen(sub);
 819
 820	if ((slen == 0) || (sublen == 0))
 821		return 1;
 822
 823	if (sublen > slen)
 824		return 1;
 825
 826	return memcmp(s + slen - sublen, sub, sublen);
 827}
 828
 829static const char *sym_name(struct elf_info *elf, Elf_Sym *sym)
 830{
 831	if (sym)
 832		return elf->strtab + sym->st_name;
 833	else
 834		return "(unknown)";
 835}
 836
 837/* The pattern is an array of simple patterns.
 838 * "foo" will match an exact string equal to "foo"
 839 * "*foo" will match a string that ends with "foo"
 840 * "foo*" will match a string that begins with "foo"
 841 * "*foo*" will match a string that contains "foo"
 842 */
 843static int match(const char *sym, const char * const pat[])
 844{
 845	const char *p;
 846	while (*pat) {
 847		p = *pat++;
 848		const char *endp = p + strlen(p) - 1;
 849
 850		/* "*foo*" */
 851		if (*p == '*' && *endp == '*') {
 852			char *bare = NOFAIL(strndup(p + 1, strlen(p) - 2));
 853			char *here = strstr(sym, bare);
 854
 855			free(bare);
 856			if (here != NULL)
 857				return 1;
 858		}
 859		/* "*foo" */
 860		else if (*p == '*') {
 861			if (strrcmp(sym, p + 1) == 0)
 862				return 1;
 863		}
 864		/* "foo*" */
 865		else if (*endp == '*') {
 866			if (strncmp(sym, p, strlen(p) - 1) == 0)
 867				return 1;
 868		}
 869		/* no wildcards */
 870		else {
 871			if (strcmp(p, sym) == 0)
 872				return 1;
 873		}
 874	}
 875	/* no match */
 876	return 0;
 877}
 878
 879/* sections that we do not want to do full section mismatch check on */
 880static const char *const section_white_list[] =
 881{
 882	".comment*",
 883	".debug*",
 884	".cranges",		/* sh64 */
 885	".zdebug*",		/* Compressed debug sections. */
 886	".GCC.command.line",	/* record-gcc-switches */
 887	".mdebug*",        /* alpha, score, mips etc. */
 888	".pdr",            /* alpha, score, mips etc. */
 889	".stab*",
 890	".note*",
 891	".got*",
 892	".toc*",
 893	".xt.prop",				 /* xtensa */
 894	".xt.lit",         /* xtensa */
 895	".arcextmap*",			/* arc */
 896	".gnu.linkonce.arcext*",	/* arc : modules */
 897	".cmem*",			/* EZchip */
 898	".fmt_slot*",			/* EZchip */
 899	".gnu.lto*",
 900	".discard.*",
 901	NULL
 902};
 903
 904/*
 905 * This is used to find sections missing the SHF_ALLOC flag.
 906 * The cause of this is often a section specified in assembler
 907 * without "ax" / "aw".
 908 */
 909static void check_section(const char *modname, struct elf_info *elf,
 910			  Elf_Shdr *sechdr)
 911{
 912	const char *sec = sech_name(elf, sechdr);
 913
 914	if (sechdr->sh_type == SHT_PROGBITS &&
 915	    !(sechdr->sh_flags & SHF_ALLOC) &&
 916	    !match(sec, section_white_list)) {
 917		warn("%s (%s): unexpected non-allocatable section.\n"
 918		     "Did you forget to use \"ax\"/\"aw\" in a .S file?\n"
 919		     "Note that for example <linux/init.h> contains\n"
 920		     "section definitions for use in .S files.\n\n",
 921		     modname, sec);
 922	}
 923}
 924
 925
 926
 927#define ALL_INIT_DATA_SECTIONS \
 928	".init.setup", ".init.rodata", ".meminit.rodata", \
 929	".init.data", ".meminit.data"
 930#define ALL_EXIT_DATA_SECTIONS \
 931	".exit.data", ".memexit.data"
 932
 933#define ALL_INIT_TEXT_SECTIONS \
 934	".init.text", ".meminit.text"
 935#define ALL_EXIT_TEXT_SECTIONS \
 936	".exit.text", ".memexit.text"
 937
 938#define ALL_PCI_INIT_SECTIONS	\
 939	".pci_fixup_early", ".pci_fixup_header", ".pci_fixup_final", \
 940	".pci_fixup_enable", ".pci_fixup_resume", \
 941	".pci_fixup_resume_early", ".pci_fixup_suspend"
 942
 943#define ALL_XXXINIT_SECTIONS MEM_INIT_SECTIONS
 944#define ALL_XXXEXIT_SECTIONS MEM_EXIT_SECTIONS
 945
 946#define ALL_INIT_SECTIONS INIT_SECTIONS, ALL_XXXINIT_SECTIONS
 947#define ALL_EXIT_SECTIONS EXIT_SECTIONS, ALL_XXXEXIT_SECTIONS
 948
 949#define DATA_SECTIONS ".data", ".data.rel"
 950#define TEXT_SECTIONS ".text", ".text.unlikely", ".sched.text", \
 951		".kprobes.text", ".cpuidle.text"
 952#define OTHER_TEXT_SECTIONS ".ref.text", ".head.text", ".spinlock.text", \
 953		".fixup", ".entry.text", ".exception.text", ".text.*", \
 954		".coldtext"
 955
 956#define INIT_SECTIONS      ".init.*"
 957#define MEM_INIT_SECTIONS  ".meminit.*"
 958
 959#define EXIT_SECTIONS      ".exit.*"
 960#define MEM_EXIT_SECTIONS  ".memexit.*"
 961
 962#define ALL_TEXT_SECTIONS  ALL_INIT_TEXT_SECTIONS, ALL_EXIT_TEXT_SECTIONS, \
 963		TEXT_SECTIONS, OTHER_TEXT_SECTIONS
 964
 965/* init data sections */
 966static const char *const init_data_sections[] =
 967	{ ALL_INIT_DATA_SECTIONS, NULL };
 968
 969/* all init sections */
 970static const char *const init_sections[] = { ALL_INIT_SECTIONS, NULL };
 971
 972/* All init and exit sections (code + data) */
 973static const char *const init_exit_sections[] =
 974	{ALL_INIT_SECTIONS, ALL_EXIT_SECTIONS, NULL };
 975
 976/* all text sections */
 977static const char *const text_sections[] = { ALL_TEXT_SECTIONS, NULL };
 978
 979/* data section */
 980static const char *const data_sections[] = { DATA_SECTIONS, NULL };
 981
 982
 983/* symbols in .data that may refer to init/exit sections */
 984#define DEFAULT_SYMBOL_WHITE_LIST					\
 985	"*driver",							\
 986	"*_template", /* scsi uses *_template a lot */			\
 987	"*_timer",    /* arm uses ops structures named _timer a lot */	\
 988	"*_sht",      /* scsi also used *_sht to some extent */		\
 989	"*_ops",							\
 990	"*_probe",							\
 991	"*_probe_one",							\
 992	"*_console"
 993
 994static const char *const head_sections[] = { ".head.text*", NULL };
 995static const char *const linker_symbols[] =
 996	{ "__init_begin", "_sinittext", "_einittext", NULL };
 997static const char *const optim_symbols[] = { "*.constprop.*", NULL };
 998
 999enum mismatch {
1000	TEXT_TO_ANY_INIT,
1001	DATA_TO_ANY_INIT,
1002	TEXT_TO_ANY_EXIT,
1003	DATA_TO_ANY_EXIT,
1004	XXXINIT_TO_SOME_INIT,
1005	XXXEXIT_TO_SOME_EXIT,
1006	ANY_INIT_TO_ANY_EXIT,
1007	ANY_EXIT_TO_ANY_INIT,
1008	EXPORT_TO_INIT_EXIT,
1009	EXTABLE_TO_NON_TEXT,
1010};
1011
1012/**
1013 * Describe how to match sections on different criterias:
1014 *
1015 * @fromsec: Array of sections to be matched.
1016 *
1017 * @bad_tosec: Relocations applied to a section in @fromsec to a section in
1018 * this array is forbidden (black-list).  Can be empty.
1019 *
1020 * @good_tosec: Relocations applied to a section in @fromsec must be
1021 * targetting sections in this array (white-list).  Can be empty.
1022 *
1023 * @mismatch: Type of mismatch.
1024 *
1025 * @symbol_white_list: Do not match a relocation to a symbol in this list
1026 * even if it is targetting a section in @bad_to_sec.
1027 *
1028 * @handler: Specific handler to call when a match is found.  If NULL,
1029 * default_mismatch_handler() will be called.
1030 *
1031 */
1032struct sectioncheck {
1033	const char *fromsec[20];
1034	const char *bad_tosec[20];
1035	const char *good_tosec[20];
1036	enum mismatch mismatch;
1037	const char *symbol_white_list[20];
1038	void (*handler)(const char *modname, struct elf_info *elf,
1039			const struct sectioncheck* const mismatch,
1040			Elf_Rela *r, Elf_Sym *sym, const char *fromsec);
1041
1042};
1043
1044static void extable_mismatch_handler(const char *modname, struct elf_info *elf,
1045				     const struct sectioncheck* const mismatch,
1046				     Elf_Rela *r, Elf_Sym *sym,
1047				     const char *fromsec);
1048
1049static const struct sectioncheck sectioncheck[] = {
1050/* Do not reference init/exit code/data from
1051 * normal code and data
1052 */
1053{
1054	.fromsec = { TEXT_SECTIONS, NULL },
1055	.bad_tosec = { ALL_INIT_SECTIONS, NULL },
1056	.mismatch = TEXT_TO_ANY_INIT,
1057	.symbol_white_list = { DEFAULT_SYMBOL_WHITE_LIST, NULL },
1058},
1059{
1060	.fromsec = { DATA_SECTIONS, NULL },
1061	.bad_tosec = { ALL_XXXINIT_SECTIONS, NULL },
1062	.mismatch = DATA_TO_ANY_INIT,
1063	.symbol_white_list = { DEFAULT_SYMBOL_WHITE_LIST, NULL },
1064},
1065{
1066	.fromsec = { DATA_SECTIONS, NULL },
1067	.bad_tosec = { INIT_SECTIONS, NULL },
1068	.mismatch = DATA_TO_ANY_INIT,
1069	.symbol_white_list = {
1070		"*_template", "*_timer", "*_sht", "*_ops",
1071		"*_probe", "*_probe_one", "*_console", NULL
1072	},
1073},
1074{
1075	.fromsec = { TEXT_SECTIONS, NULL },
1076	.bad_tosec = { ALL_EXIT_SECTIONS, NULL },
1077	.mismatch = TEXT_TO_ANY_EXIT,
1078	.symbol_white_list = { DEFAULT_SYMBOL_WHITE_LIST, NULL },
1079},
1080{
1081	.fromsec = { DATA_SECTIONS, NULL },
1082	.bad_tosec = { ALL_EXIT_SECTIONS, NULL },
1083	.mismatch = DATA_TO_ANY_EXIT,
1084	.symbol_white_list = { DEFAULT_SYMBOL_WHITE_LIST, NULL },
1085},
1086/* Do not reference init code/data from meminit code/data */
1087{
1088	.fromsec = { ALL_XXXINIT_SECTIONS, NULL },
1089	.bad_tosec = { INIT_SECTIONS, NULL },
1090	.mismatch = XXXINIT_TO_SOME_INIT,
1091	.symbol_white_list = { DEFAULT_SYMBOL_WHITE_LIST, NULL },
1092},
1093/* Do not reference exit code/data from memexit code/data */
1094{
1095	.fromsec = { ALL_XXXEXIT_SECTIONS, NULL },
1096	.bad_tosec = { EXIT_SECTIONS, NULL },
1097	.mismatch = XXXEXIT_TO_SOME_EXIT,
1098	.symbol_white_list = { DEFAULT_SYMBOL_WHITE_LIST, NULL },
1099},
1100/* Do not use exit code/data from init code */
1101{
1102	.fromsec = { ALL_INIT_SECTIONS, NULL },
1103	.bad_tosec = { ALL_EXIT_SECTIONS, NULL },
1104	.mismatch = ANY_INIT_TO_ANY_EXIT,
1105	.symbol_white_list = { DEFAULT_SYMBOL_WHITE_LIST, NULL },
1106},
1107/* Do not use init code/data from exit code */
1108{
1109	.fromsec = { ALL_EXIT_SECTIONS, NULL },
1110	.bad_tosec = { ALL_INIT_SECTIONS, NULL },
1111	.mismatch = ANY_EXIT_TO_ANY_INIT,
1112	.symbol_white_list = { DEFAULT_SYMBOL_WHITE_LIST, NULL },
1113},
1114{
1115	.fromsec = { ALL_PCI_INIT_SECTIONS, NULL },
1116	.bad_tosec = { INIT_SECTIONS, NULL },
1117	.mismatch = ANY_INIT_TO_ANY_EXIT,
1118	.symbol_white_list = { NULL },
1119},
1120/* Do not export init/exit functions or data */
1121{
1122	.fromsec = { "__ksymtab*", NULL },
1123	.bad_tosec = { INIT_SECTIONS, EXIT_SECTIONS, NULL },
1124	.mismatch = EXPORT_TO_INIT_EXIT,
1125	.symbol_white_list = { DEFAULT_SYMBOL_WHITE_LIST, NULL },
1126},
1127{
1128	.fromsec = { "__ex_table", NULL },
1129	/* If you're adding any new black-listed sections in here, consider
1130	 * adding a special 'printer' for them in scripts/check_extable.
1131	 */
1132	.bad_tosec = { ".altinstr_replacement", NULL },
1133	.good_tosec = {ALL_TEXT_SECTIONS , NULL},
1134	.mismatch = EXTABLE_TO_NON_TEXT,
1135	.handler = extable_mismatch_handler,
1136}
1137};
1138
1139static const struct sectioncheck *section_mismatch(
1140		const char *fromsec, const char *tosec)
1141{
1142	int i;
1143	int elems = sizeof(sectioncheck) / sizeof(struct sectioncheck);
1144	const struct sectioncheck *check = &sectioncheck[0];
1145
1146	/*
1147	 * The target section could be the SHT_NUL section when we're
1148	 * handling relocations to un-resolved symbols, trying to match it
1149	 * doesn't make much sense and causes build failures on parisc
1150	 * architectures.
1151	 */
1152	if (*tosec == '\0')
1153		return NULL;
1154
1155	for (i = 0; i < elems; i++) {
1156		if (match(fromsec, check->fromsec)) {
1157			if (check->bad_tosec[0] && match(tosec, check->bad_tosec))
1158				return check;
1159			if (check->good_tosec[0] && !match(tosec, check->good_tosec))
1160				return check;
1161		}
1162		check++;
1163	}
1164	return NULL;
1165}
1166
1167/**
1168 * Whitelist to allow certain references to pass with no warning.
1169 *
1170 * Pattern 1:
1171 *   If a module parameter is declared __initdata and permissions=0
1172 *   then this is legal despite the warning generated.
1173 *   We cannot see value of permissions here, so just ignore
1174 *   this pattern.
1175 *   The pattern is identified by:
1176 *   tosec   = .init.data
1177 *   fromsec = .data*
1178 *   atsym   =__param*
1179 *
1180 * Pattern 1a:
1181 *   module_param_call() ops can refer to __init set function if permissions=0
1182 *   The pattern is identified by:
1183 *   tosec   = .init.text
1184 *   fromsec = .data*
1185 *   atsym   = __param_ops_*
1186 *
1187 * Pattern 2:
1188 *   Many drivers utilise a *driver container with references to
1189 *   add, remove, probe functions etc.
1190 *   the pattern is identified by:
1191 *   tosec   = init or exit section
1192 *   fromsec = data section
1193 *   atsym = *driver, *_template, *_sht, *_ops, *_probe,
1194 *           *probe_one, *_console, *_timer
1195 *
1196 * Pattern 3:
1197 *   Whitelist all references from .head.text to any init section
1198 *
1199 * Pattern 4:
1200 *   Some symbols belong to init section but still it is ok to reference
1201 *   these from non-init sections as these symbols don't have any memory
1202 *   allocated for them and symbol address and value are same. So even
1203 *   if init section is freed, its ok to reference those symbols.
1204 *   For ex. symbols marking the init section boundaries.
1205 *   This pattern is identified by
1206 *   refsymname = __init_begin, _sinittext, _einittext
1207 *
1208 * Pattern 5:
1209 *   GCC may optimize static inlines when fed constant arg(s) resulting
1210 *   in functions like cpumask_empty() -- generating an associated symbol
1211 *   cpumask_empty.constprop.3 that appears in the audit.  If the const that
1212 *   is passed in comes from __init, like say nmi_ipi_mask, we get a
1213 *   meaningless section warning.  May need to add isra symbols too...
1214 *   This pattern is identified by
1215 *   tosec   = init section
1216 *   fromsec = text section
1217 *   refsymname = *.constprop.*
1218 *
1219 * Pattern 6:
1220 *   Hide section mismatch warnings for ELF local symbols.  The goal
1221 *   is to eliminate false positive modpost warnings caused by
1222 *   compiler-generated ELF local symbol names such as ".LANCHOR1".
1223 *   Autogenerated symbol names bypass modpost's "Pattern 2"
1224 *   whitelisting, which relies on pattern-matching against symbol
1225 *   names to work.  (One situation where gcc can autogenerate ELF
1226 *   local symbols is when "-fsection-anchors" is used.)
1227 **/
1228static int secref_whitelist(const struct sectioncheck *mismatch,
1229			    const char *fromsec, const char *fromsym,
1230			    const char *tosec, const char *tosym)
1231{
1232	/* Check for pattern 1 */
1233	if (match(tosec, init_data_sections) &&
1234	    match(fromsec, data_sections) &&
1235	    strstarts(fromsym, "__param"))
1236		return 0;
1237
1238	/* Check for pattern 1a */
1239	if (strcmp(tosec, ".init.text") == 0 &&
1240	    match(fromsec, data_sections) &&
1241	    strstarts(fromsym, "__param_ops_"))
1242		return 0;
1243
1244	/* Check for pattern 2 */
1245	if (match(tosec, init_exit_sections) &&
1246	    match(fromsec, data_sections) &&
1247	    match(fromsym, mismatch->symbol_white_list))
1248		return 0;
1249
1250	/* Check for pattern 3 */
1251	if (match(fromsec, head_sections) &&
1252	    match(tosec, init_sections))
1253		return 0;
1254
1255	/* Check for pattern 4 */
1256	if (match(tosym, linker_symbols))
1257		return 0;
1258
1259	/* Check for pattern 5 */
1260	if (match(fromsec, text_sections) &&
1261	    match(tosec, init_sections) &&
1262	    match(fromsym, optim_symbols))
1263		return 0;
1264
1265	/* Check for pattern 6 */
1266	if (strstarts(fromsym, ".L"))
1267		return 0;
1268
1269	return 1;
1270}
1271
1272static inline int is_arm_mapping_symbol(const char *str)
1273{
1274	return str[0] == '$' && strchr("axtd", str[1])
1275	       && (str[2] == '\0' || str[2] == '.');
1276}
1277
1278/*
1279 * If there's no name there, ignore it; likewise, ignore it if it's
1280 * one of the magic symbols emitted used by current ARM tools.
1281 *
1282 * Otherwise if find_symbols_between() returns those symbols, they'll
1283 * fail the whitelist tests and cause lots of false alarms ... fixable
1284 * only by merging __exit and __init sections into __text, bloating
1285 * the kernel (which is especially evil on embedded platforms).
1286 */
1287static inline int is_valid_name(struct elf_info *elf, Elf_Sym *sym)
1288{
1289	const char *name = elf->strtab + sym->st_name;
1290
1291	if (!name || !strlen(name))
1292		return 0;
1293	return !is_arm_mapping_symbol(name);
1294}
1295
1296/**
1297 * Find symbol based on relocation record info.
1298 * In some cases the symbol supplied is a valid symbol so
1299 * return refsym. If st_name != 0 we assume this is a valid symbol.
1300 * In other cases the symbol needs to be looked up in the symbol table
1301 * based on section and address.
1302 *  **/
1303static Elf_Sym *find_elf_symbol(struct elf_info *elf, Elf64_Sword addr,
1304				Elf_Sym *relsym)
1305{
1306	Elf_Sym *sym;
1307	Elf_Sym *near = NULL;
1308	Elf64_Sword distance = 20;
1309	Elf64_Sword d;
1310	unsigned int relsym_secindex;
1311
1312	if (relsym->st_name != 0)
1313		return relsym;
1314
1315	relsym_secindex = get_secindex(elf, relsym);
1316	for (sym = elf->symtab_start; sym < elf->symtab_stop; sym++) {
1317		if (get_secindex(elf, sym) != relsym_secindex)
1318			continue;
1319		if (ELF_ST_TYPE(sym->st_info) == STT_SECTION)
1320			continue;
1321		if (!is_valid_name(elf, sym))
1322			continue;
1323		if (sym->st_value == addr)
1324			return sym;
1325		/* Find a symbol nearby - addr are maybe negative */
1326		d = sym->st_value - addr;
1327		if (d < 0)
1328			d = addr - sym->st_value;
1329		if (d < distance) {
1330			distance = d;
1331			near = sym;
1332		}
1333	}
1334	/* We need a close match */
1335	if (distance < 20)
1336		return near;
1337	else
1338		return NULL;
1339}
1340
1341/*
1342 * Find symbols before or equal addr and after addr - in the section sec.
1343 * If we find two symbols with equal offset prefer one with a valid name.
1344 * The ELF format may have a better way to detect what type of symbol
1345 * it is, but this works for now.
1346 **/
1347static Elf_Sym *find_elf_symbol2(struct elf_info *elf, Elf_Addr addr,
1348				 const char *sec)
1349{
1350	Elf_Sym *sym;
1351	Elf_Sym *near = NULL;
1352	Elf_Addr distance = ~0;
1353
1354	for (sym = elf->symtab_start; sym < elf->symtab_stop; sym++) {
1355		const char *symsec;
1356
1357		if (is_shndx_special(sym->st_shndx))
1358			continue;
1359		symsec = sec_name(elf, get_secindex(elf, sym));
1360		if (strcmp(symsec, sec) != 0)
1361			continue;
1362		if (!is_valid_name(elf, sym))
1363			continue;
1364		if (sym->st_value <= addr) {
1365			if ((addr - sym->st_value) < distance) {
1366				distance = addr - sym->st_value;
1367				near = sym;
1368			} else if ((addr - sym->st_value) == distance) {
1369				near = sym;
1370			}
1371		}
1372	}
1373	return near;
1374}
1375
1376/*
1377 * Convert a section name to the function/data attribute
1378 * .init.text => __init
1379 * .memexitconst => __memconst
1380 * etc.
1381 *
1382 * The memory of returned value has been allocated on a heap. The user of this
1383 * method should free it after usage.
1384*/
1385static char *sec2annotation(const char *s)
1386{
1387	if (match(s, init_exit_sections)) {
1388		char *p = NOFAIL(malloc(20));
1389		char *r = p;
1390
1391		*p++ = '_';
1392		*p++ = '_';
1393		if (*s == '.')
1394			s++;
1395		while (*s && *s != '.')
1396			*p++ = *s++;
1397		*p = '\0';
1398		if (*s == '.')
1399			s++;
1400		if (strstr(s, "rodata") != NULL)
1401			strcat(p, "const ");
1402		else if (strstr(s, "data") != NULL)
1403			strcat(p, "data ");
1404		else
1405			strcat(p, " ");
1406		return r;
1407	} else {
1408		return NOFAIL(strdup(""));
1409	}
1410}
1411
1412static int is_function(Elf_Sym *sym)
1413{
1414	if (sym)
1415		return ELF_ST_TYPE(sym->st_info) == STT_FUNC;
1416	else
1417		return -1;
1418}
1419
1420static void print_section_list(const char * const list[20])
1421{
1422	const char *const *s = list;
1423
1424	while (*s) {
1425		fprintf(stderr, "%s", *s);
1426		s++;
1427		if (*s)
1428			fprintf(stderr, ", ");
1429	}
1430	fprintf(stderr, "\n");
1431}
1432
1433static inline void get_pretty_name(int is_func, const char** name, const char** name_p)
1434{
1435	switch (is_func) {
1436	case 0:	*name = "variable"; *name_p = ""; break;
1437	case 1:	*name = "function"; *name_p = "()"; break;
1438	default: *name = "(unknown reference)"; *name_p = ""; break;
1439	}
1440}
1441
1442/*
1443 * Print a warning about a section mismatch.
1444 * Try to find symbols near it so user can find it.
1445 * Check whitelist before warning - it may be a false positive.
1446 */
1447static void report_sec_mismatch(const char *modname,
1448				const struct sectioncheck *mismatch,
1449				const char *fromsec,
1450				unsigned long long fromaddr,
1451				const char *fromsym,
1452				int from_is_func,
1453				const char *tosec, const char *tosym,
1454				int to_is_func)
1455{
1456	const char *from, *from_p;
1457	const char *to, *to_p;
1458	char *prl_from;
1459	char *prl_to;
1460
1461	sec_mismatch_count++;
1462
1463	get_pretty_name(from_is_func, &from, &from_p);
1464	get_pretty_name(to_is_func, &to, &to_p);
1465
1466	warn("%s(%s+0x%llx): Section mismatch in reference from the %s %s%s "
1467	     "to the %s %s:%s%s\n",
1468	     modname, fromsec, fromaddr, from, fromsym, from_p, to, tosec,
1469	     tosym, to_p);
1470
1471	switch (mismatch->mismatch) {
1472	case TEXT_TO_ANY_INIT:
1473		prl_from = sec2annotation(fromsec);
1474		prl_to = sec2annotation(tosec);
1475		fprintf(stderr,
1476		"The function %s%s() references\n"
1477		"the %s %s%s%s.\n"
1478		"This is often because %s lacks a %s\n"
1479		"annotation or the annotation of %s is wrong.\n",
1480		prl_from, fromsym,
1481		to, prl_to, tosym, to_p,
1482		fromsym, prl_to, tosym);
1483		free(prl_from);
1484		free(prl_to);
1485		break;
1486	case DATA_TO_ANY_INIT: {
1487		prl_to = sec2annotation(tosec);
1488		fprintf(stderr,
1489		"The variable %s references\n"
1490		"the %s %s%s%s\n"
1491		"If the reference is valid then annotate the\n"
1492		"variable with __init* or __refdata (see linux/init.h) "
1493		"or name the variable:\n",
1494		fromsym, to, prl_to, tosym, to_p);
1495		print_section_list(mismatch->symbol_white_list);
1496		free(prl_to);
1497		break;
1498	}
1499	case TEXT_TO_ANY_EXIT:
1500		prl_to = sec2annotation(tosec);
1501		fprintf(stderr,
1502		"The function %s() references a %s in an exit section.\n"
1503		"Often the %s %s%s has valid usage outside the exit section\n"
1504		"and the fix is to remove the %sannotation of %s.\n",
1505		fromsym, to, to, tosym, to_p, prl_to, tosym);
1506		free(prl_to);
1507		break;
1508	case DATA_TO_ANY_EXIT: {
1509		prl_to = sec2annotation(tosec);
1510		fprintf(stderr,
1511		"The variable %s references\n"
1512		"the %s %s%s%s\n"
1513		"If the reference is valid then annotate the\n"
1514		"variable with __exit* (see linux/init.h) or "
1515		"name the variable:\n",
1516		fromsym, to, prl_to, tosym, to_p);
1517		print_section_list(mismatch->symbol_white_list);
1518		free(prl_to);
1519		break;
1520	}
1521	case XXXINIT_TO_SOME_INIT:
1522	case XXXEXIT_TO_SOME_EXIT:
1523		prl_from = sec2annotation(fromsec);
1524		prl_to = sec2annotation(tosec);
1525		fprintf(stderr,
1526		"The %s %s%s%s references\n"
1527		"a %s %s%s%s.\n"
1528		"If %s is only used by %s then\n"
1529		"annotate %s with a matching annotation.\n",
1530		from, prl_from, fromsym, from_p,
1531		to, prl_to, tosym, to_p,
1532		tosym, fromsym, tosym);
1533		free(prl_from);
1534		free(prl_to);
1535		break;
1536	case ANY_INIT_TO_ANY_EXIT:
1537		prl_from = sec2annotation(fromsec);
1538		prl_to = sec2annotation(tosec);
1539		fprintf(stderr,
1540		"The %s %s%s%s references\n"
1541		"a %s %s%s%s.\n"
1542		"This is often seen when error handling "
1543		"in the init function\n"
1544		"uses functionality in the exit path.\n"
1545		"The fix is often to remove the %sannotation of\n"
1546		"%s%s so it may be used outside an exit section.\n",
1547		from, prl_from, fromsym, from_p,
1548		to, prl_to, tosym, to_p,
1549		prl_to, tosym, to_p);
1550		free(prl_from);
1551		free(prl_to);
1552		break;
1553	case ANY_EXIT_TO_ANY_INIT:
1554		prl_from = sec2annotation(fromsec);
1555		prl_to = sec2annotation(tosec);
1556		fprintf(stderr,
1557		"The %s %s%s%s references\n"
1558		"a %s %s%s%s.\n"
1559		"This is often seen when error handling "
1560		"in the exit function\n"
1561		"uses functionality in the init path.\n"
1562		"The fix is often to remove the %sannotation of\n"
1563		"%s%s so it may be used outside an init section.\n",
1564		from, prl_from, fromsym, from_p,
1565		to, prl_to, tosym, to_p,
1566		prl_to, tosym, to_p);
1567		free(prl_from);
1568		free(prl_to);
1569		break;
1570	case EXPORT_TO_INIT_EXIT:
1571		prl_to = sec2annotation(tosec);
1572		fprintf(stderr,
1573		"The symbol %s is exported and annotated %s\n"
1574		"Fix this by removing the %sannotation of %s "
1575		"or drop the export.\n",
1576		tosym, prl_to, prl_to, tosym);
1577		free(prl_to);
1578		break;
1579	case EXTABLE_TO_NON_TEXT:
1580		fatal("There's a special handler for this mismatch type, "
1581		      "we should never get here.");
1582		break;
1583	}
1584	fprintf(stderr, "\n");
1585}
1586
1587static void default_mismatch_handler(const char *modname, struct elf_info *elf,
1588				     const struct sectioncheck* const mismatch,
1589				     Elf_Rela *r, Elf_Sym *sym, const char *fromsec)
1590{
1591	const char *tosec;
1592	Elf_Sym *to;
1593	Elf_Sym *from;
1594	const char *tosym;
1595	const char *fromsym;
1596
1597	from = find_elf_symbol2(elf, r->r_offset, fromsec);
1598	fromsym = sym_name(elf, from);
1599
1600	if (strstarts(fromsym, "reference___initcall"))
1601		return;
1602
1603	tosec = sec_name(elf, get_secindex(elf, sym));
1604	to = find_elf_symbol(elf, r->r_addend, sym);
1605	tosym = sym_name(elf, to);
1606
1607	/* check whitelist - we may ignore it */
1608	if (secref_whitelist(mismatch,
1609			     fromsec, fromsym, tosec, tosym)) {
1610		report_sec_mismatch(modname, mismatch,
1611				    fromsec, r->r_offset, fromsym,
1612				    is_function(from), tosec, tosym,
1613				    is_function(to));
1614	}
1615}
1616
1617static int is_executable_section(struct elf_info* elf, unsigned int section_index)
1618{
1619	if (section_index > elf->num_sections)
1620		fatal("section_index is outside elf->num_sections!\n");
1621
1622	return ((elf->sechdrs[section_index].sh_flags & SHF_EXECINSTR) == SHF_EXECINSTR);
1623}
1624
1625/*
1626 * We rely on a gross hack in section_rel[a]() calling find_extable_entry_size()
1627 * to know the sizeof(struct exception_table_entry) for the target architecture.
1628 */
1629static unsigned int extable_entry_size = 0;
1630static void find_extable_entry_size(const char* const sec, const Elf_Rela* r)
1631{
1632	/*
1633	 * If we're currently checking the second relocation within __ex_table,
1634	 * that relocation offset tells us the offsetof(struct
1635	 * exception_table_entry, fixup) which is equal to sizeof(struct
1636	 * exception_table_entry) divided by two.  We use that to our advantage
1637	 * since there's no portable way to get that size as every architecture
1638	 * seems to go with different sized types.  Not pretty but better than
1639	 * hard-coding the size for every architecture..
1640	 */
1641	if (!extable_entry_size)
1642		extable_entry_size = r->r_offset * 2;
1643}
1644
1645static inline bool is_extable_fault_address(Elf_Rela *r)
1646{
1647	/*
1648	 * extable_entry_size is only discovered after we've handled the
1649	 * _second_ relocation in __ex_table, so only abort when we're not
1650	 * handling the first reloc and extable_entry_size is zero.
1651	 */
1652	if (r->r_offset && extable_entry_size == 0)
1653		fatal("extable_entry size hasn't been discovered!\n");
1654
1655	return ((r->r_offset == 0) ||
1656		(r->r_offset % extable_entry_size == 0));
1657}
1658
1659#define is_second_extable_reloc(Start, Cur, Sec)			\
1660	(((Cur) == (Start) + 1) && (strcmp("__ex_table", (Sec)) == 0))
1661
1662static void report_extable_warnings(const char* modname, struct elf_info* elf,
1663				    const struct sectioncheck* const mismatch,
1664				    Elf_Rela* r, Elf_Sym* sym,
1665				    const char* fromsec, const char* tosec)
1666{
1667	Elf_Sym* fromsym = find_elf_symbol2(elf, r->r_offset, fromsec);
1668	const char* fromsym_name = sym_name(elf, fromsym);
1669	Elf_Sym* tosym = find_elf_symbol(elf, r->r_addend, sym);
1670	const char* tosym_name = sym_name(elf, tosym);
1671	const char* from_pretty_name;
1672	const char* from_pretty_name_p;
1673	const char* to_pretty_name;
1674	const char* to_pretty_name_p;
1675
1676	get_pretty_name(is_function(fromsym),
1677			&from_pretty_name, &from_pretty_name_p);
1678	get_pretty_name(is_function(tosym),
1679			&to_pretty_name, &to_pretty_name_p);
1680
1681	warn("%s(%s+0x%lx): Section mismatch in reference"
1682	     " from the %s %s%s to the %s %s:%s%s\n",
1683	     modname, fromsec, (long)r->r_offset, from_pretty_name,
1684	     fromsym_name, from_pretty_name_p,
1685	     to_pretty_name, tosec, tosym_name, to_pretty_name_p);
1686
1687	if (!match(tosec, mismatch->bad_tosec) &&
1688	    is_executable_section(elf, get_secindex(elf, sym)))
1689		fprintf(stderr,
1690			"The relocation at %s+0x%lx references\n"
1691			"section \"%s\" which is not in the list of\n"
1692			"authorized sections.  If you're adding a new section\n"
1693			"and/or if this reference is valid, add \"%s\" to the\n"
1694			"list of authorized sections to jump to on fault.\n"
1695			"This can be achieved by adding \"%s\" to \n"
1696			"OTHER_TEXT_SECTIONS in scripts/mod/modpost.c.\n",
1697			fromsec, (long)r->r_offset, tosec, tosec, tosec);
1698}
1699
1700static void extable_mismatch_handler(const char* modname, struct elf_info *elf,
1701				     const struct sectioncheck* const mismatch,
1702				     Elf_Rela* r, Elf_Sym* sym,
1703				     const char *fromsec)
1704{
1705	const char* tosec = sec_name(elf, get_secindex(elf, sym));
1706
1707	sec_mismatch_count++;
1708
1709	report_extable_warnings(modname, elf, mismatch, r, sym, fromsec, tosec);
1710
1711	if (match(tosec, mismatch->bad_tosec))
1712		fatal("The relocation at %s+0x%lx references\n"
1713		      "section \"%s\" which is black-listed.\n"
1714		      "Something is seriously wrong and should be fixed.\n"
1715		      "You might get more information about where this is\n"
1716		      "coming from by using scripts/check_extable.sh %s\n",
1717		      fromsec, (long)r->r_offset, tosec, modname);
1718	else if (!is_executable_section(elf, get_secindex(elf, sym))) {
1719		if (is_extable_fault_address(r))
1720			fatal("The relocation at %s+0x%lx references\n"
1721			      "section \"%s\" which is not executable, IOW\n"
1722			      "it is not possible for the kernel to fault\n"
1723			      "at that address.  Something is seriously wrong\n"
1724			      "and should be fixed.\n",
1725			      fromsec, (long)r->r_offset, tosec);
1726		else
1727			fatal("The relocation at %s+0x%lx references\n"
1728			      "section \"%s\" which is not executable, IOW\n"
1729			      "the kernel will fault if it ever tries to\n"
1730			      "jump to it.  Something is seriously wrong\n"
1731			      "and should be fixed.\n",
1732			      fromsec, (long)r->r_offset, tosec);
1733	}
1734}
1735
1736static void check_section_mismatch(const char *modname, struct elf_info *elf,
1737				   Elf_Rela *r, Elf_Sym *sym, const char *fromsec)
1738{
1739	const char *tosec = sec_name(elf, get_secindex(elf, sym));
1740	const struct sectioncheck *mismatch = section_mismatch(fromsec, tosec);
1741
1742	if (mismatch) {
1743		if (mismatch->handler)
1744			mismatch->handler(modname, elf,  mismatch,
1745					  r, sym, fromsec);
1746		else
1747			default_mismatch_handler(modname, elf, mismatch,
1748						 r, sym, fromsec);
1749	}
1750}
1751
1752static unsigned int *reloc_location(struct elf_info *elf,
1753				    Elf_Shdr *sechdr, Elf_Rela *r)
1754{
1755	Elf_Shdr *sechdrs = elf->sechdrs;
1756	int section = sechdr->sh_info;
1757
1758	return (void *)elf->hdr + sechdrs[section].sh_offset +
1759		r->r_offset;
1760}
1761
1762static int addend_386_rel(struct elf_info *elf, Elf_Shdr *sechdr, Elf_Rela *r)
1763{
1764	unsigned int r_typ = ELF_R_TYPE(r->r_info);
1765	unsigned int *location = reloc_location(elf, sechdr, r);
1766
1767	switch (r_typ) {
1768	case R_386_32:
1769		r->r_addend = TO_NATIVE(*location);
1770		break;
1771	case R_386_PC32:
1772		r->r_addend = TO_NATIVE(*location) + 4;
1773		/* For CONFIG_RELOCATABLE=y */
1774		if (elf->hdr->e_type == ET_EXEC)
1775			r->r_addend += r->r_offset;
1776		break;
1777	}
1778	return 0;
1779}
1780
1781#ifndef R_ARM_CALL
1782#define R_ARM_CALL	28
1783#endif
1784#ifndef R_ARM_JUMP24
1785#define R_ARM_JUMP24	29
1786#endif
1787
1788#ifndef	R_ARM_THM_CALL
1789#define	R_ARM_THM_CALL		10
1790#endif
1791#ifndef	R_ARM_THM_JUMP24
1792#define	R_ARM_THM_JUMP24	30
1793#endif
1794#ifndef	R_ARM_THM_JUMP19
1795#define	R_ARM_THM_JUMP19	51
1796#endif
1797
1798static int addend_arm_rel(struct elf_info *elf, Elf_Shdr *sechdr, Elf_Rela *r)
1799{
1800	unsigned int

Large files files are truncated, but you can click here to view the full file