Commit 91fb02f3 authored by Aaron Tomlin's avatar Aaron Tomlin Committed by Luis Chamberlain
Browse files

module: Move kallsyms support into a separate file 



No functional change.

This patch migrates kallsyms code out of core module
code kernel/module/kallsyms.c

Signed-off-by: default avatarAaron Tomlin <atomlin@redhat.com>
Signed-off-by: default avatarLuis Chamberlain <mcgrof@kernel.org>
parent 473c84d1

kernel/module/Makefile

+1 −0
Original line number Diff line number Diff line
@@ -14,3 +14,4 @@ obj-$(CONFIG_LIVEPATCH) += livepatch.o 
obj-$(CONFIG_MODULES_TREE_LOOKUP) += tree_lookup.o

obj-$(CONFIG_STRICT_MODULE_RWX) += strict_rwx.o

obj-$(CONFIG_DEBUG_KMEMLEAK) += debug_kmemleak.o

obj-$(CONFIG_KALLSYMS) += kallsyms.o

kernel/module/internal.h

+29 −0
Original line number Diff line number Diff line
@@ -68,6 +68,19 @@ struct load_info { 
};



int mod_verify_sig(const void *mod, struct load_info *info);

struct module *find_module_all(const char *name, size_t len, bool even_unformed);

int cmp_name(const void *name, const void *sym);

long module_get_offset(struct module *mod, unsigned int *size, Elf_Shdr *sechdr,

		       unsigned int section);



static inline unsigned long kernel_symbol_value(const struct kernel_symbol *sym)

{

#ifdef CONFIG_HAVE_ARCH_PREL32_RELOCATIONS

	return (unsigned long)offset_to_ptr(&sym->value_offset);

#else

	return sym->value;

#endif

}



#ifdef CONFIG_LIVEPATCH

int copy_module_elf(struct module *mod, struct load_info *info);
@@ -174,3 +187,19 @@ void kmemleak_load_module(const struct module *mod, const struct load_info *info 
static inline void kmemleak_load_module(const struct module *mod,

					const struct load_info *info) { }

#endif /* CONFIG_DEBUG_KMEMLEAK */



#ifdef CONFIG_KALLSYMS

void init_build_id(struct module *mod, const struct load_info *info);

void layout_symtab(struct module *mod, struct load_info *info);

void add_kallsyms(struct module *mod, const struct load_info *info);

unsigned long find_kallsyms_symbol_value(struct module *mod, const char *name);



static inline bool sect_empty(const Elf_Shdr *sect)

{

	return !(sect->sh_flags & SHF_ALLOC) || sect->sh_size == 0;

}

#else /* !CONFIG_KALLSYMS */

static inline void init_build_id(struct module *mod, const struct load_info *info) { }

static inline void layout_symtab(struct module *mod, struct load_info *info) { }

static inline void add_kallsyms(struct module *mod, const struct load_info *info) { }

#endif /* CONFIG_KALLSYMS */

kernel/module/kallsyms.c

0 → 100644
+502 −0
Original line number Diff line number Diff line 
// SPDX-License-Identifier: GPL-2.0-or-later

/*

 * Module kallsyms support

 *

 * Copyright (C) 2010 Rusty Russell

 */



#include <linux/module.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;



	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;

	if (!(sec->sh_flags & SHF_ALLOC)

#ifndef CONFIG_KALLSYMS_ALL

	    || !(sec->sh_flags & SHF_EXECINSTR)

#endif

	    || (sec->sh_entsize & INIT_OFFSET_MASK))

		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;



	/* Put symbol section at end of init part of module. */

	symsect->sh_flags |= SHF_ALLOC;

	symsect->sh_entsize = module_get_offset(mod, &mod->init_layout.size, symsect,

						info->index.sym) | INIT_OFFSET_MASK;

	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->core_layout.size, symsect->sh_addralign ?: 1);

	info->stroffs = mod->core_layout.size = info->symoffs + ndst * sizeof(Elf_Sym);

	mod->core_layout.size += strtab_size;

	info->core_typeoffs = mod->core_layout.size;

	mod->core_layout.size += ndst * sizeof(char);

	mod->core_layout.size = debug_align(mod->core_layout.size);



	/* Put string table section at end of init part of module. */

	strsect->sh_flags |= SHF_ALLOC;

	strsect->sh_entsize = module_get_offset(mod, &mod->init_layout.size, strsect,

						info->index.str) | INIT_OFFSET_MASK;

	pr_debug("\t%s\n", info->secstrings + strsect->sh_name);



	/* We'll tack temporary mod_kallsyms on the end. */

	mod->init_layout.size = ALIGN(mod->init_layout.size,

				      __alignof__(struct mod_kallsyms));

	info->mod_kallsyms_init_off = mod->init_layout.size;

	mod->init_layout.size += sizeof(struct mod_kallsyms);

	info->init_typeoffs = mod->init_layout.size;

	mod->init_layout.size += nsrc * sizeof(char);

	mod->init_layout.size = debug_align(mod->init_layout.size);

}



/*

 * 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];



	/* Set up to point into init section. */

	mod->kallsyms = mod->init_layout.base + info->mod_kallsyms_init_off;



	/* The following is safe since this pointer cannot change */

	mod->kallsyms->symtab = (void *)symsec->sh_addr;

	mod->kallsyms->num_symtab = symsec->sh_size / sizeof(Elf_Sym);

	/* Make sure we get permanent strtab: don't use info->strtab. */

	mod->kallsyms->strtab = (void *)info->sechdrs[info->index.str].sh_addr;

	mod->kallsyms->typetab = mod->init_layout.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 = mod->core_layout.base + info->symoffs;

	mod->core_kallsyms.strtab = s = mod->core_layout.base + info->stroffs;

	mod->core_kallsyms.typetab = mod->core_layout.base + info->core_typeoffs;

	src = mod->kallsyms->symtab;

	for (ndst = i = 0; i < mod->kallsyms->num_symtab; i++) {

		mod->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)) {

			mod->core_kallsyms.typetab[ndst] =

			    mod->kallsyms->typetab[i];

			dst[ndst] = src[i];

			dst[ndst++].st_name = s - mod->core_kallsyms.strtab;

			s += strscpy(s, &mod->kallsyms->strtab[src[i].st_name],

				     KSYM_NAME_LEN) + 1;

		}

	}

	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;

	}

}

#else

void init_build_id(struct module *mod, const struct load_info *info)

{

}

#endif



/*

 * This ignores the intensely annoying "mapping symbols" found

 * in ARM ELF files: $a, $t and $d.

 */

static inline int is_arm_mapping_symbol(const char *str)

{

	if (str[0] == '.' && str[1] == 'L')

		return true;

	return str[0] == '$' && strchr("axtd", str[1]) &&

	       (str[2] == '\0' || str[2] == '.');

}



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_sched(mod->kallsyms);



	/* At worse, next value is at end of module */

	if (within_module_init(addr, mod))

		nextval = (unsigned long)mod->init_layout.base + mod->init_layout.text_size;

	else

		nextval = (unsigned long)mod->core_layout.base + mod->core_layout.text_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_arm_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, simply disable preemption.

 */

const char *module_address_lookup(unsigned long addr,

				  unsigned long *size,

			    unsigned long *offset,

			    char **modname,

			    const unsigned char **modbuildid,

			    char *namebuf)

{

	const char *ret = NULL;

	struct module *mod;



	preempt_disable();

	mod = __module_address(addr);

	if (mod) {

		if (modname)

			*modname = mod->name;

		if (modbuildid) {

#if IS_ENABLED(CONFIG_STACKTRACE_BUILD_ID)

			*modbuildid = mod->build_id;

#else

			*modbuildid = NULL;

#endif

		}



		ret = find_kallsyms_symbol(mod, addr, size, offset);

	}

	/* Make a copy in here where it's safe */

	if (ret) {

		strncpy(namebuf, ret, KSYM_NAME_LEN - 1);

		ret = namebuf;

	}

	preempt_enable();



	return ret;

}



int lookup_module_symbol_name(unsigned long addr, char *symname)

{

	struct module *mod;



	preempt_disable();

	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);

			preempt_enable();

			return 0;

		}

	}

out:

	preempt_enable();

	return -ERANGE;

}



int lookup_module_symbol_attrs(unsigned long addr, unsigned long *size,

			       unsigned long *offset, char *modname, char *name)

{

	struct module *mod;



	preempt_disable();

	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, size, offset);

			if (!sym)

				goto out;

			if (modname)

				strscpy(modname, mod->name, MODULE_NAME_LEN);

			if (name)

				strscpy(name, sym, KSYM_NAME_LEN);

			preempt_enable();

			return 0;

		}

	}

out:

	preempt_enable();

	return -ERANGE;

}



int module_get_kallsym(unsigned int symnum, unsigned long *value, char *type,

		       char *name, char *module_name, int *exported)

{

	struct module *mod;



	preempt_disable();

	list_for_each_entry_rcu(mod, &modules, list) {

		struct mod_kallsyms *kallsyms;



		if (mod->state == MODULE_STATE_UNFORMED)

			continue;

		kallsyms = rcu_dereference_sched(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);

			preempt_enable();

			return 0;

		}

		symnum -= kallsyms->num_symtab;

	}

	preempt_enable();

	return -ERANGE;

}



/* Given a module and name of symbol, find and return the symbol's value */

unsigned long find_kallsyms_symbol_value(struct module *mod, const char *name)

{

	unsigned int i;

	struct mod_kallsyms *kallsyms = rcu_dereference_sched(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;

}



/* Look for this name: can be of form module:name. */

unsigned long module_kallsyms_lookup_name(const char *name)

{

	struct module *mod;

	char *colon;

	unsigned long ret = 0;



	/* Don't lock: we're in enough trouble already. */

	preempt_disable();

	if ((colon = strnchr(name, MODULE_NAME_LEN, ':')) != NULL) {

		if ((mod = find_module_all(name, colon - name, false)) != NULL)

			ret = find_kallsyms_symbol_value(mod, colon + 1);

	} else {

		list_for_each_entry_rcu(mod, &modules, list) {

			if (mod->state == MODULE_STATE_UNFORMED)

				continue;

			if ((ret = find_kallsyms_symbol_value(mod, name)) != 0)

				break;

		}

	}

	preempt_enable();

	return ret;

}



#ifdef CONFIG_LIVEPATCH

int module_kallsyms_on_each_symbol(int (*fn)(void *, const char *,

					     struct module *, unsigned long),

				   void *data)

{

	struct module *mod;

	unsigned int i;

	int ret = 0;



	mutex_lock(&module_mutex);

	list_for_each_entry(mod, &modules, list) {

		/* We hold module_mutex: no need for rcu_dereference_sched */

		struct mod_kallsyms *kallsyms = mod->kallsyms;



		if (mod->state == MODULE_STATE_UNFORMED)

			continue;

		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),

				 mod, kallsyms_symbol_value(sym));

			if (ret != 0)

				goto out;

		}

	}

out:

	mutex_unlock(&module_mutex);

	return ret;

}

#endif /* CONFIG_LIVEPATCH */

kernel/module/main.c

+6 −525

File changed.

Preview size limit exceeded, changes collapsed.