// SPDX-License-Identifier: GPL-2.0-or-later/* * Module kallsyms support * * Copyright (C) 2010 Rusty Russell */ #include <linux/module.h>#include <linux/module_symbol.h>#include <linux/kallsyms.h>#include <linux/buildid.h>#include <linux/bsearch.h>#include "internal.h" /* Lookup exported symbol in given range of kernel_symbols */static const struct kernel_symbol *lookup_exported_symbol(const char *name,							  const struct kernel_symbol *start,							  const struct kernel_symbol *stop){	return bsearch(name, start, stop - start,			sizeof(struct kernel_symbol), cmp_name);} static int is_exported(const char *name, unsigned long value,		       const struct module *mod){	const struct kernel_symbol *ks; 	if (!mod)		ks = lookup_exported_symbol(name, __start___ksymtab, __stop___ksymtab);	else		ks = lookup_exported_symbol(name, mod->syms, mod->syms + mod->num_syms); 	return ks && kernel_symbol_value(ks) == value;} /* As per nm */static char elf_type(const Elf_Sym *sym, const struct load_info *info){	const Elf_Shdr *sechdrs = info->sechdrs; 	if (ELF_ST_BIND(sym->st_info) == STB_WEAK) {		if (ELF_ST_TYPE(sym->st_info) == STT_OBJECT)			return 'v';		else			return 'w';	}	if (sym->st_shndx == SHN_UNDEF)		return 'U';	if (sym->st_shndx == SHN_ABS || sym->st_shndx == info->index.pcpu)		return 'a';	if (sym->st_shndx >= SHN_LORESERVE)		return '?';	if (sechdrs[sym->st_shndx].sh_flags & SHF_EXECINSTR)		return 't';	if (sechdrs[sym->st_shndx].sh_flags & SHF_ALLOC &&	    sechdrs[sym->st_shndx].sh_type != SHT_NOBITS) {		if (!(sechdrs[sym->st_shndx].sh_flags & SHF_WRITE))			return 'r';		else if (sechdrs[sym->st_shndx].sh_flags & ARCH_SHF_SMALL)			return 'g';		else			return 'd';	}	if (sechdrs[sym->st_shndx].sh_type == SHT_NOBITS) {		if (sechdrs[sym->st_shndx].sh_flags & ARCH_SHF_SMALL)			return 's';		else			return 'b';	}	if (strstarts(info->secstrings + sechdrs[sym->st_shndx].sh_name,		      ".debug")) {		return 'n';	}	return '?';} static bool is_core_symbol(const Elf_Sym *src, const Elf_Shdr *sechdrs,			   unsigned int shnum, unsigned int pcpundx){	const Elf_Shdr *sec;	enum mod_mem_type type; 	if (src->st_shndx == SHN_UNDEF ||	    src->st_shndx >= shnum ||	    !src->st_name)		return false; #ifdef CONFIG_KALLSYMS_ALL	if (src->st_shndx == pcpundx)		return true;#endif 	sec = sechdrs + src->st_shndx;	type = sec->sh_entsize >> SH_ENTSIZE_TYPE_SHIFT;	if (!(sec->sh_flags & SHF_ALLOC)#ifndef CONFIG_KALLSYMS_ALL	    || !(sec->sh_flags & SHF_EXECINSTR)#endif	    || mod_mem_type_is_init(type))		return false; 	return true;} /* * We only allocate and copy the strings needed by the parts of symtab * we keep.  This is simple, but has the effect of making multiple * copies of duplicates.  We could be more sophisticated, see * linux-kernel thread starting with * <73defb5e4bca04a6431392cc341112b1@localhost>. */void layout_symtab(struct module *mod, struct load_info *info){	Elf_Shdr *symsect = info->sechdrs + info->index.sym;	Elf_Shdr *strsect = info->sechdrs + info->index.str;	const Elf_Sym *src;	unsigned int i, nsrc, ndst, strtab_size = 0;	struct module_memory *mod_mem_data = &mod->mem[MOD_DATA];	struct module_memory *mod_mem_init_data = &mod->mem[MOD_INIT_DATA]; 	/* Put symbol section at end of init part of module. */	symsect->sh_flags |= SHF_ALLOC;	symsect->sh_entsize = module_get_offset_and_type(mod, MOD_INIT_DATA,							 symsect, info->index.sym);	pr_debug("\t%s\n", info->secstrings + symsect->sh_name); 	src = (void *)info->hdr + symsect->sh_offset;	nsrc = symsect->sh_size / sizeof(*src); 	/* Compute total space required for the core symbols' strtab. */	for (ndst = i = 0; i < nsrc; i++) {		if (i == 0 || is_livepatch_module(mod) ||		    is_core_symbol(src + i, info->sechdrs, info->hdr->e_shnum,				   info->index.pcpu)) {			strtab_size += strlen(&info->strtab[src[i].st_name]) + 1;			ndst++;		}	} 	/* Append room for core symbols at end of core part. */	info->symoffs = ALIGN(mod_mem_data->size, symsect->sh_addralign ?: 1);	info->stroffs = mod_mem_data->size = info->symoffs + ndst * sizeof(Elf_Sym);	mod_mem_data->size += strtab_size;	/* Note add_kallsyms() computes strtab_size as core_typeoffs - stroffs */	info->core_typeoffs = mod_mem_data->size;	mod_mem_data->size += ndst * sizeof(char); 	/* Put string table section at end of init part of module. */	strsect->sh_flags |= SHF_ALLOC;	strsect->sh_entsize = module_get_offset_and_type(mod, MOD_INIT_DATA,							 strsect, info->index.str);	pr_debug("\t%s\n", info->secstrings + strsect->sh_name); 	/* We'll tack temporary mod_kallsyms on the end. */	mod_mem_init_data->size = ALIGN(mod_mem_init_data->size,					__alignof__(struct mod_kallsyms));	info->mod_kallsyms_init_off = mod_mem_init_data->size; 	mod_mem_init_data->size += sizeof(struct mod_kallsyms);	info->init_typeoffs = mod_mem_init_data->size;	mod_mem_init_data->size += nsrc * sizeof(char);} /* * We use the full symtab and strtab which layout_symtab arranged to * be appended to the init section.  Later we switch to the cut-down * core-only ones. */void add_kallsyms(struct module *mod, const struct load_info *info){	unsigned int i, ndst;	const Elf_Sym *src;	Elf_Sym *dst;	char *s;	Elf_Shdr *symsec = &info->sechdrs[info->index.sym];	unsigned long strtab_size;	void *data_base = mod->mem[MOD_DATA].base;	void *init_data_base = mod->mem[MOD_INIT_DATA].base;	struct mod_kallsyms *kallsyms; 	kallsyms = init_data_base + info->mod_kallsyms_init_off; 	kallsyms->symtab = (void *)symsec->sh_addr;	kallsyms->num_symtab = symsec->sh_size / sizeof(Elf_Sym);	/* Make sure we get permanent strtab: don't use info->strtab. */	kallsyms->strtab = (void *)info->sechdrs[info->index.str].sh_addr;	kallsyms->typetab = init_data_base + info->init_typeoffs; 	/*	 * Now populate the cut down core kallsyms for after init	 * and set types up while we still have access to sections.	 */	mod->core_kallsyms.symtab = dst = data_base + info->symoffs;	mod->core_kallsyms.strtab = s = data_base + info->stroffs;	mod->core_kallsyms.typetab = data_base + info->core_typeoffs;	strtab_size = info->core_typeoffs - info->stroffs;	src = kallsyms->symtab;	for (ndst = i = 0; i < kallsyms->num_symtab; i++) {		kallsyms->typetab[i] = elf_type(src + i, info);		if (i == 0 || is_livepatch_module(mod) ||		    is_core_symbol(src + i, info->sechdrs, info->hdr->e_shnum,				   info->index.pcpu)) {			ssize_t ret; 			mod->core_kallsyms.typetab[ndst] =				kallsyms->typetab[i];			dst[ndst] = src[i];			dst[ndst++].st_name = s - mod->core_kallsyms.strtab;			ret = strscpy(s, &kallsyms->strtab[src[i].st_name],				      strtab_size);			if (ret < 0)				break;			s += ret + 1;			strtab_size -= ret + 1;		}	} 	/* Set up to point into init section. */	rcu_assign_pointer(mod->kallsyms, kallsyms);	mod->core_kallsyms.num_symtab = ndst;} #if IS_ENABLED(CONFIG_STACKTRACE_BUILD_ID)void init_build_id(struct module *mod, const struct load_info *info){	const Elf_Shdr *sechdr;	unsigned int i; 	for (i = 0; i < info->hdr->e_shnum; i++) {		sechdr = &info->sechdrs[i];		if (!sect_empty(sechdr) && sechdr->sh_type == SHT_NOTE &&		    !build_id_parse_buf((void *)sechdr->sh_addr, mod->build_id,					sechdr->sh_size))			break;	}}#elsevoid init_build_id(struct module *mod, const struct load_info *info){}#endif static const char *kallsyms_symbol_name(struct mod_kallsyms *kallsyms, unsigned int symnum){	return kallsyms->strtab + kallsyms->symtab[symnum].st_name;} /* * Given a module and address, find the corresponding symbol and return its name * while providing its size and offset if needed. */static const char *find_kallsyms_symbol(struct module *mod,					unsigned long addr,					unsigned long *size,					unsigned long *offset){	unsigned int i, best = 0;	unsigned long nextval, bestval;	struct mod_kallsyms *kallsyms = rcu_dereference(mod->kallsyms);	struct module_memory *mod_mem; 	/* At worse, next value is at end of module */	if (within_module_init(addr, mod))		mod_mem = &mod->mem[MOD_INIT_TEXT];	else		mod_mem = &mod->mem[MOD_TEXT]; 	nextval = (unsigned long)mod_mem->base + mod_mem->size; 	bestval = kallsyms_symbol_value(&kallsyms->symtab[best]); 	/*	 * Scan for closest preceding symbol, and next symbol. (ELF	 * starts real symbols at 1).	 */	for (i = 1; i < kallsyms->num_symtab; i++) {		const Elf_Sym *sym = &kallsyms->symtab[i];		unsigned long thisval = kallsyms_symbol_value(sym); 		if (sym->st_shndx == SHN_UNDEF)			continue; 		/*		 * We ignore unnamed symbols: they're uninformative		 * and inserted at a whim.		 */		if (*kallsyms_symbol_name(kallsyms, i) == '\0' ||		    is_mapping_symbol(kallsyms_symbol_name(kallsyms, i)))			continue; 		if (thisval <= addr && thisval > bestval) {			best = i;			bestval = thisval;		}		if (thisval > addr && thisval < nextval)			nextval = thisval;	} 	if (!best)		return NULL; 	if (size)		*size = nextval - bestval;	if (offset)		*offset = addr - bestval; 	return kallsyms_symbol_name(kallsyms, best);} void * __weak dereference_module_function_descriptor(struct module *mod,						     void *ptr){	return ptr;} /* * For kallsyms to ask for address resolution.  NULL means not found.  Careful * not to lock to avoid deadlock on oopses, RCU is enough. */int module_address_lookup(unsigned long addr,			  unsigned long *size,			  unsigned long *offset,			  char **modname,			  const unsigned char **modbuildid,			  char *namebuf){	const char *sym;	int ret = 0;	struct module *mod; 	guard(rcu)();	mod = __module_address(addr);	if (mod) {		if (modname)			*modname = mod->name;		if (modbuildid)			*modbuildid = module_buildid(mod); 		sym = find_kallsyms_symbol(mod, addr, size, offset); 		if (sym)			ret = strscpy(namebuf, sym, KSYM_NAME_LEN);	}	return ret;} int lookup_module_symbol_name(unsigned long addr, char *symname){	struct module *mod; 	guard(rcu)();	list_for_each_entry_rcu(mod, &modules, list) {		if (mod->state == MODULE_STATE_UNFORMED)			continue;		if (within_module(addr, mod)) {			const char *sym; 			sym = find_kallsyms_symbol(mod, addr, NULL, NULL);			if (!sym)				goto out; 			strscpy(symname, sym, KSYM_NAME_LEN);			return 0;		}	}out:	return -ERANGE;} int module_get_kallsym(unsigned int symnum, unsigned long *value, char *type,		       char *name, char *module_name, int *exported){	struct module *mod; 	guard(rcu)();	list_for_each_entry_rcu(mod, &modules, list) {		struct mod_kallsyms *kallsyms; 		if (mod->state == MODULE_STATE_UNFORMED)			continue;		kallsyms = rcu_dereference(mod->kallsyms);		if (symnum < kallsyms->num_symtab) {			const Elf_Sym *sym = &kallsyms->symtab[symnum]; 			*value = kallsyms_symbol_value(sym);			*type = kallsyms->typetab[symnum];			strscpy(name, kallsyms_symbol_name(kallsyms, symnum), KSYM_NAME_LEN);			strscpy(module_name, mod->name, MODULE_NAME_LEN);			*exported = is_exported(name, *value, mod);			return 0;		}		symnum -= kallsyms->num_symtab;	}	return -ERANGE;} /* Given a module and name of symbol, find and return the symbol's value */static unsigned long __find_kallsyms_symbol_value(struct module *mod, const char *name){	unsigned int i;	struct mod_kallsyms *kallsyms = rcu_dereference(mod->kallsyms); 	for (i = 0; i < kallsyms->num_symtab; i++) {		const Elf_Sym *sym = &kallsyms->symtab[i]; 		if (strcmp(name, kallsyms_symbol_name(kallsyms, i)) == 0 &&		    sym->st_shndx != SHN_UNDEF)			return kallsyms_symbol_value(sym);	}	return 0;} static unsigned long __module_kallsyms_lookup_name(const char *name){	struct module *mod;	char *colon; 	colon = strnchr(name, MODULE_NAME_LEN, ':');	if (colon) {		mod = find_module_all(name, colon - name, false);		if (mod)			return __find_kallsyms_symbol_value(mod, colon + 1);		return 0;	} 	list_for_each_entry_rcu(mod, &modules, list) {		unsigned long ret; 		if (mod->state == MODULE_STATE_UNFORMED)			continue;		ret = __find_kallsyms_symbol_value(mod, name);		if (ret)			return ret;	}	return 0;} /* Look for this name: can be of form module:name. */unsigned long module_kallsyms_lookup_name(const char *name){	/* Don't lock: we're in enough trouble already. */	guard(rcu)();	return __module_kallsyms_lookup_name(name);} unsigned long find_kallsyms_symbol_value(struct module *mod, const char *name){	guard(rcu)();	return __find_kallsyms_symbol_value(mod, name);} int module_kallsyms_on_each_symbol(const char *modname,				   int (*fn)(void *, const char *, unsigned long),				   void *data){	struct module *mod;	unsigned int i;	int ret = 0; 	mutex_lock(&module_mutex);	list_for_each_entry(mod, &modules, list) {		struct mod_kallsyms *kallsyms; 		if (mod->state == MODULE_STATE_UNFORMED)			continue; 		if (modname && strcmp(modname, mod->name))			continue; 		kallsyms = rcu_dereference_check(mod->kallsyms,						 lockdep_is_held(&module_mutex)); 		for (i = 0; i < kallsyms->num_symtab; i++) {			const Elf_Sym *sym = &kallsyms->symtab[i]; 			if (sym->st_shndx == SHN_UNDEF)				continue; 			ret = fn(data, kallsyms_symbol_name(kallsyms, i),				 kallsyms_symbol_value(sym));			if (ret != 0)				goto out;		} 		/*		 * The given module is found, the subsequent modules do not		 * need to be compared.		 */		if (modname)			break;	}out:	mutex_unlock(&module_mutex);	return ret;}