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