[linux-block.git] / arch / mips / kernel / module.c

/*
 *  This program is free software; you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation; either version 2 of the License, or
 *  (at your option) any later version.
 *
 *  This program is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with this program; if not, write to the Free Software
 *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 *
 *  Copyright (C) 2001 Rusty Russell.
 *  Copyright (C) 2003, 2004 Ralf Baechle (ralf@linux-mips.org)
 *  Copyright (C) 2005 Thiemo Seufer
 */

#undef DEBUG

#include <linux/extable.h>
#include <linux/moduleloader.h>
#include <linux/elf.h>
#include <linux/mm.h>
#include <linux/numa.h>
#include <linux/vmalloc.h>
#include <linux/slab.h>
#include <linux/fs.h>
#include <linux/string.h>
#include <linux/kernel.h>
#include <linux/spinlock.h>
#include <linux/jump_label.h>

#include <asm/pgtable.h>	/* MODULE_START */

struct mips_hi16 {
	struct mips_hi16 *next;
	Elf_Addr *addr;
	Elf_Addr value;
};

static LIST_HEAD(dbe_list);
static DEFINE_SPINLOCK(dbe_lock);

#ifdef MODULE_START
void *module_alloc(unsigned long size)
{
	return __vmalloc_node_range(size, 1, MODULE_START, MODULE_END,
				GFP_KERNEL, PAGE_KERNEL, 0, NUMA_NO_NODE,
				__builtin_return_address(0));
}
#endif

static int apply_r_mips_none(struct module *me, u32 *location,
			     u32 base, Elf_Addr v, bool rela)
{
	return 0;
}

static int apply_r_mips_32(struct module *me, u32 *location,
			   u32 base, Elf_Addr v, bool rela)
{
	*location = base + v;

	return 0;
}

static int apply_r_mips_26(struct module *me, u32 *location,
			   u32 base, Elf_Addr v, bool rela)
{
	if (v % 4) {
		pr_err("module %s: dangerous R_MIPS_26 relocation\n",
		       me->name);
		return -ENOEXEC;
	}

	if ((v & 0xf0000000) != (((unsigned long)location + 4) & 0xf0000000)) {
		pr_err("module %s: relocation overflow\n",
		       me->name);
		return -ENOEXEC;
	}

	*location = (*location & ~0x03ffffff) |
		    ((base + (v >> 2)) & 0x03ffffff);

	return 0;
}

static int apply_r_mips_hi16(struct module *me, u32 *location,
			     u32 base, Elf_Addr v, bool rela)
{
	struct mips_hi16 *n;

	if (rela) {
		*location = (*location & 0xffff0000) |
			    ((((long long) v + 0x8000LL) >> 16) & 0xffff);
		return 0;
	}

	/*
	 * We cannot relocate this one now because we don't know the value of
	 * the carry we need to add.  Save the information, and let LO16 do the
	 * actual relocation.
	 */
	n = kmalloc(sizeof *n, GFP_KERNEL);
	if (!n)
		return -ENOMEM;

	n->addr = (Elf_Addr *)location;
	n->value = v;
	n->next = me->arch.r_mips_hi16_list;
	me->arch.r_mips_hi16_list = n;

	return 0;
}

static void free_relocation_chain(struct mips_hi16 *l)
{
	struct mips_hi16 *next;

	while (l) {
		next = l->next;
		kfree(l);
		l = next;
	}
}

static int apply_r_mips_lo16(struct module *me, u32 *location,
			     u32 base, Elf_Addr v, bool rela)
{
	unsigned long insnlo = base;
	struct mips_hi16 *l;
	Elf_Addr val, vallo;

	if (rela) {
		*location = (*location & 0xffff0000) | (v & 0xffff);
		return 0;
	}

	/* Sign extend the addend we extract from the lo insn.	*/
	vallo = ((insnlo & 0xffff) ^ 0x8000) - 0x8000;

	if (me->arch.r_mips_hi16_list != NULL) {
		l = me->arch.r_mips_hi16_list;
		while (l != NULL) {
			struct mips_hi16 *next;
			unsigned long insn;

			/*
			 * The value for the HI16 had best be the same.
			 */
			if (v != l->value)
				goto out_danger;

			/*
			 * Do the HI16 relocation.  Note that we actually don't
			 * need to know anything about the LO16 itself, except
			 * where to find the low 16 bits of the addend needed
			 * by the LO16.
			 */
			insn = *l->addr;
			val = ((insn & 0xffff) << 16) + vallo;
			val += v;

			/*
			 * Account for the sign extension that will happen in
			 * the low bits.
			 */
			val = ((val >> 16) + ((val & 0x8000) != 0)) & 0xffff;

			insn = (insn & ~0xffff) | val;
			*l->addr = insn;

			next = l->next;
			kfree(l);
			l = next;
		}

		me->arch.r_mips_hi16_list = NULL;
	}

	/*
	 * Ok, we're done with the HI16 relocs.	 Now deal with the LO16.
	 */
	val = v + vallo;
	insnlo = (insnlo & ~0xffff) | (val & 0xffff);
	*location = insnlo;

	return 0;

out_danger:
	free_relocation_chain(l);
	me->arch.r_mips_hi16_list = NULL;

	pr_err("module %s: dangerous R_MIPS_LO16 relocation\n", me->name);

	return -ENOEXEC;
}

static int apply_r_mips_pc(struct module *me, u32 *location, u32 base,
			   Elf_Addr v, unsigned int bits)
{
	unsigned long mask = GENMASK(bits - 1, 0);
	unsigned long se_bits;
	long offset;

	if (v % 4) {
		pr_err("module %s: dangerous R_MIPS_PC%u relocation\n",
		       me->name, bits);
		return -ENOEXEC;
	}

	/* retrieve & sign extend implicit addend if any */
	offset = base & mask;
	offset |= (offset & BIT(bits - 1)) ? ~mask : 0;

	offset += ((long)v - (long)location) >> 2;

	/* check the sign bit onwards are identical - ie. we didn't overflow */
	se_bits = (offset & BIT(bits - 1)) ? ~0ul : 0;
	if ((offset & ~mask) != (se_bits & ~mask)) {
		pr_err("module %s: relocation overflow\n", me->name);
		return -ENOEXEC;
	}

	*location = (*location & ~mask) | (offset & mask);

	return 0;
}

static int apply_r_mips_pc16(struct module *me, u32 *location,
			     u32 base, Elf_Addr v, bool rela)
{
	return apply_r_mips_pc(me, location, base, v, 16);
}

static int apply_r_mips_pc21(struct module *me, u32 *location,
			     u32 base, Elf_Addr v, bool rela)
{
	return apply_r_mips_pc(me, location, base, v, 21);
}

static int apply_r_mips_pc26(struct module *me, u32 *location,
			     u32 base, Elf_Addr v, bool rela)
{
	return apply_r_mips_pc(me, location, base, v, 26);
}

static int apply_r_mips_64(struct module *me, u32 *location,
			   u32 base, Elf_Addr v, bool rela)
{
	if (WARN_ON(!rela))
		return -EINVAL;

	*(Elf_Addr *)location = v;

	return 0;
}

static int apply_r_mips_higher(struct module *me, u32 *location,
			       u32 base, Elf_Addr v, bool rela)
{
	if (WARN_ON(!rela))
		return -EINVAL;

	*location = (*location & 0xffff0000) |
		    ((((long long)v + 0x80008000LL) >> 32) & 0xffff);

	return 0;
}

static int apply_r_mips_highest(struct module *me, u32 *location,
				u32 base, Elf_Addr v, bool rela)
{
	if (WARN_ON(!rela))
		return -EINVAL;

	*location = (*location & 0xffff0000) |
		    ((((long long)v + 0x800080008000LL) >> 48) & 0xffff);

	return 0;
}

/**
 * reloc_handler() - Apply a particular relocation to a module
 * @me: the module to apply the reloc to
 * @location: the address at which the reloc is to be applied
 * @base: the existing value at location for REL-style; 0 for RELA-style
 * @v: the value of the reloc, with addend for RELA-style
 *
 * Each implemented reloc_handler function applies a particular type of
 * relocation to the module @me. Relocs that may be found in either REL or RELA
 * variants can be handled by making use of the @base & @v parameters which are
 * set to values which abstract the difference away from the particular reloc
 * implementations.
 *
 * Return: 0 upon success, else -ERRNO
 */
typedef int (*reloc_handler)(struct module *me, u32 *location,
			     u32 base, Elf_Addr v, bool rela);

/* The handlers for known reloc types */
static reloc_handler reloc_handlers[] = {
	[R_MIPS_NONE]		= apply_r_mips_none,
	[R_MIPS_32]		= apply_r_mips_32,
	[R_MIPS_26]		= apply_r_mips_26,
	[R_MIPS_HI16]		= apply_r_mips_hi16,
	[R_MIPS_LO16]		= apply_r_mips_lo16,
	[R_MIPS_PC16]		= apply_r_mips_pc16,
	[R_MIPS_64]		= apply_r_mips_64,
	[R_MIPS_HIGHER]		= apply_r_mips_higher,
	[R_MIPS_HIGHEST]	= apply_r_mips_highest,
	[R_MIPS_PC21_S2]	= apply_r_mips_pc21,
	[R_MIPS_PC26_S2]	= apply_r_mips_pc26,
};

static int __apply_relocate(Elf_Shdr *sechdrs, const char *strtab,
			    unsigned int symindex, unsigned int relsec,
			    struct module *me, bool rela)
{
	union {
		Elf_Mips_Rel *rel;
		Elf_Mips_Rela *rela;
	} r;
	reloc_handler handler;
	Elf_Sym *sym;
	u32 *location, base;
	unsigned int i, type;
	Elf_Addr v;
	int err = 0;
	size_t reloc_sz;

	pr_debug("Applying relocate section %u to %u\n", relsec,
	       sechdrs[relsec].sh_info);

	r.rel = (void *)sechdrs[relsec].sh_addr;
	reloc_sz = rela ? sizeof(*r.rela) : sizeof(*r.rel);
	me->arch.r_mips_hi16_list = NULL;
	for (i = 0; i < sechdrs[relsec].sh_size / reloc_sz; i++) {
		/* This is where to make the change */
		location = (void *)sechdrs[sechdrs[relsec].sh_info].sh_addr
			+ r.rel->r_offset;
		/* This is the symbol it is referring to */
		sym = (Elf_Sym *)sechdrs[symindex].sh_addr
			+ ELF_MIPS_R_SYM(*r.rel);
		if (sym->st_value >= -MAX_ERRNO) {
			/* Ignore unresolved weak symbol */
			if (ELF_ST_BIND(sym->st_info) == STB_WEAK)
				continue;
			pr_warn("%s: Unknown symbol %s\n",
				me->name, strtab + sym->st_name);
			err = -ENOENT;
			goto out;
		}

		type = ELF_MIPS_R_TYPE(*r.rel);
		if (type < ARRAY_SIZE(reloc_handlers))
			handler = reloc_handlers[type];
		else
			handler = NULL;

		if (!handler) {
			pr_err("%s: Unknown relocation type %u\n",
			       me->name, type);
			err = -EINVAL;
			goto out;
		}

		if (rela) {
			v = sym->st_value + r.rela->r_addend;
			base = 0;
			r.rela = &r.rela[1];
		} else {
			v = sym->st_value;
			base = *location;
			r.rel = &r.rel[1];
		}

		err = handler(me, location, base, v, rela);
		if (err)
			goto out;
	}

out:
	/*
	 * Normally the hi16 list should be deallocated at this point. A
	 * malformed binary however could contain a series of R_MIPS_HI16
	 * relocations not followed by a R_MIPS_LO16 relocation, or if we hit
	 * an error processing a reloc we might have gotten here before
	 * reaching the R_MIPS_LO16. In either case, free up the list and
	 * return an error.
	 */
	if (me->arch.r_mips_hi16_list) {
		free_relocation_chain(me->arch.r_mips_hi16_list);
		me->arch.r_mips_hi16_list = NULL;
		err = err ?: -ENOEXEC;
	}

	return err;
}

int apply_relocate(Elf_Shdr *sechdrs, const char *strtab,
		   unsigned int symindex, unsigned int relsec,
		   struct module *me)
{
	return __apply_relocate(sechdrs, strtab, symindex, relsec, me, false);
}

#ifdef CONFIG_MODULES_USE_ELF_RELA
int apply_relocate_add(Elf_Shdr *sechdrs, const char *strtab,
		       unsigned int symindex, unsigned int relsec,
		       struct module *me)
{
	return __apply_relocate(sechdrs, strtab, symindex, relsec, me, true);
}
#endif /* CONFIG_MODULES_USE_ELF_RELA */

/* Given an address, look for it in the module exception tables. */
const struct exception_table_entry *search_module_dbetables(unsigned long addr)
{
	unsigned long flags;
	const struct exception_table_entry *e = NULL;
	struct mod_arch_specific *dbe;

	spin_lock_irqsave(&dbe_lock, flags);
	list_for_each_entry(dbe, &dbe_list, dbe_list) {
		e = search_extable(dbe->dbe_start,
				   dbe->dbe_end - dbe->dbe_start, addr);
		if (e)
			break;
	}
	spin_unlock_irqrestore(&dbe_lock, flags);

	/* Now, if we found one, we are running inside it now, hence
	   we cannot unload the module, hence no refcnt needed. */
	return e;
}

/* Put in dbe list if necessary. */
int module_finalize(const Elf_Ehdr *hdr,
		    const Elf_Shdr *sechdrs,
		    struct module *me)
{
	const Elf_Shdr *s;
	char *secstrings = (void *)hdr + sechdrs[hdr->e_shstrndx].sh_offset;

	/* Make jump label nops. */
	jump_label_apply_nops(me);

	INIT_LIST_HEAD(&me->arch.dbe_list);
	for (s = sechdrs; s < sechdrs + hdr->e_shnum; s++) {
		if (strcmp("__dbe_table", secstrings + s->sh_name) != 0)
			continue;
		me->arch.dbe_start = (void *)s->sh_addr;
		me->arch.dbe_end = (void *)s->sh_addr + s->sh_size;
		spin_lock_irq(&dbe_lock);
		list_add(&me->arch.dbe_list, &dbe_list);
		spin_unlock_irq(&dbe_lock);
	}
	return 0;
}

void module_arch_cleanup(struct module *mod)
{
	spin_lock_irq(&dbe_lock);
	list_del(&mod->arch.dbe_list);
	spin_unlock_irq(&dbe_lock);
}
Commit	Line	Data
4e6a05fe TS	1	/*
	2	* This program is free software; you can redistribute it and/or modify
	3	* it under the terms of the GNU General Public License as published by
	4	* the Free Software Foundation; either version 2 of the License, or
	5	* (at your option) any later version.
	6	*
	7	* This program is distributed in the hope that it will be useful,
	8	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	9	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	10	* GNU General Public License for more details.
	11	*
	12	* You should have received a copy of the GNU General Public License
	13	* along with this program; if not, write to the Free Software
	14	* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
	15	*
	16	* Copyright (C) 2001 Rusty Russell.
	17	* Copyright (C) 2003, 2004 Ralf Baechle (ralf@linux-mips.org)
	18	* Copyright (C) 2005 Thiemo Seufer
	19	*/
	20
	21	#undef DEBUG
	22
9f3b8081	23	#include <linux/extable.h>
4e6a05fe TS	24	#include <linux/moduleloader.h>
4e6a05fe TS	25	#include <linux/elf.h>
27ac792c	26	#include <linux/mm.h>
761845f0	27	#include <linux/numa.h>
4e6a05fe TS	28	#include <linux/vmalloc.h>
	29	#include <linux/slab.h>
	30	#include <linux/fs.h>
	31	#include <linux/string.h>
	32	#include <linux/kernel.h>
1da177e4	33	#include <linux/spinlock.h>
94bb0c1a DD	34	#include <linux/jump_label.h>
94bb0c1a DD	35
656be92f	36	#include <asm/pgtable.h> /* MODULE_START */
1da177e4	37
4e6a05fe TS	38	struct mips_hi16 {
	39	struct mips_hi16 *next;
	40	Elf_Addr *addr;
	41	Elf_Addr value;
	42	};
	43
1da177e4 LT	44	static LIST_HEAD(dbe_list);
	45	static DEFINE_SPINLOCK(dbe_lock);
	46
66574cc0	47	#ifdef MODULE_START
4e6a05fe TS	48	void *module_alloc(unsigned long size)
4e6a05fe TS	49	{
d0a21265	50	return __vmalloc_node_range(size, 1, MODULE_START, MODULE_END,
cb9e3c29	51	GFP_KERNEL, PAGE_KERNEL, 0, NUMA_NO_NODE,
d0a21265	52	__builtin_return_address(0));
4e6a05fe	53	}
66574cc0	54	#endif
4e6a05fe	55
430d0b88 PB	56	static int apply_r_mips_none(struct module me, u32 location,
430d0b88 PB	57	u32 base, Elf_Addr v, bool rela)
4e6a05fe TS	58	{
	59	return 0;
	60	}
	61
430d0b88 PB	62	static int apply_r_mips_32(struct module me, u32 location,
430d0b88 PB	63	u32 base, Elf_Addr v, bool rela)
4e6a05fe	64	{
430d0b88	65	*location = base + v;
4e6a05fe TS	66
	67	return 0;
	68	}
	69
430d0b88 PB	70	static int apply_r_mips_26(struct module me, u32 location,
430d0b88 PB	71	u32 base, Elf_Addr v, bool rela)
4e6a05fe TS	72	{
4e6a05fe TS	73	if (v % 4) {
430d0b88	74	pr_err("module %s: dangerous R_MIPS_26 relocation\n",
6f9fdeb6	75	me->name);
4e6a05fe TS	76	return -ENOEXEC;
	77	}
	78
	79	if ((v & 0xf0000000) != (((unsigned long)location + 4) & 0xf0000000)) {
55d791f3	80	pr_err("module %s: relocation overflow\n",
4e6a05fe TS	81	me->name);
	82	return -ENOEXEC;
	83	}
	84
	85	location = (location & ~0x03ffffff) \|
430d0b88	86	((base + (v >> 2)) & 0x03ffffff);
4e6a05fe TS	87
	88	return 0;
	89	}
	90
430d0b88 PB	91	static int apply_r_mips_hi16(struct module me, u32 location,
430d0b88 PB	92	u32 base, Elf_Addr v, bool rela)
4e6a05fe TS	93	{
	94	struct mips_hi16 *n;
	95
430d0b88 PB	96	if (rela) {
	97	location = (location & 0xffff0000) \|
	98	((((long long) v + 0x8000LL) >> 16) & 0xffff);
	99	return 0;
	100	}
	101
4e6a05fe TS	102	/*
	103	* We cannot relocate this one now because we don't know the value of
	104	* the carry we need to add. Save the information, and let LO16 do the
	105	* actual relocation.
	106	*/
	107	n = kmalloc(sizeof *n, GFP_KERNEL);
	108	if (!n)
	109	return -ENOMEM;
	110
	111	n->addr = (Elf_Addr *)location;
	112	n->value = v;
861667dc RB	113	n->next = me->arch.r_mips_hi16_list;
861667dc RB	114	me->arch.r_mips_hi16_list = n;
4e6a05fe TS	115
	116	return 0;
	117	}
	118
c54de490 RB	119	static void free_relocation_chain(struct mips_hi16 *l)
	120	{
	121	struct mips_hi16 *next;
	122
	123	while (l) {
	124	next = l->next;
	125	kfree(l);
	126	l = next;
	127	}
	128	}
	129
430d0b88 PB	130	static int apply_r_mips_lo16(struct module me, u32 location,
430d0b88 PB	131	u32 base, Elf_Addr v, bool rela)
4e6a05fe	132	{
430d0b88	133	unsigned long insnlo = base;
c54de490	134	struct mips_hi16 *l;
4e6a05fe TS	135	Elf_Addr val, vallo;
4e6a05fe TS	136
430d0b88 PB	137	if (rela) {
	138	location = (location & 0xffff0000) \| (v & 0xffff);
	139	return 0;
	140	}
	141
70342287	142	/* Sign extend the addend we extract from the lo insn. */
4e6a05fe TS	143	vallo = ((insnlo & 0xffff) ^ 0x8000) - 0x8000;
4e6a05fe TS	144
861667dc	145	if (me->arch.r_mips_hi16_list != NULL) {
861667dc	146	l = me->arch.r_mips_hi16_list;
4e6a05fe	147	while (l != NULL) {
c54de490	148	struct mips_hi16 *next;
4e6a05fe TS	149	unsigned long insn;
	150
	151	/*
	152	* The value for the HI16 had best be the same.
	153	*/
	154	if (v != l->value)
	155	goto out_danger;
	156
	157	/*
	158	* Do the HI16 relocation. Note that we actually don't
	159	* need to know anything about the LO16 itself, except
	160	* where to find the low 16 bits of the addend needed
	161	* by the LO16.
	162	*/
	163	insn = *l->addr;
	164	val = ((insn & 0xffff) << 16) + vallo;
	165	val += v;
	166
	167	/*
	168	* Account for the sign extension that will happen in
	169	* the low bits.
	170	*/
	171	val = ((val >> 16) + ((val & 0x8000) != 0)) & 0xffff;
	172
	173	insn = (insn & ~0xffff) \| val;
	174	*l->addr = insn;
	175
	176	next = l->next;
	177	kfree(l);
	178	l = next;
	179	}
	180
861667dc	181	me->arch.r_mips_hi16_list = NULL;
4e6a05fe TS	182	}
	183
	184	/*
70342287	185	* Ok, we're done with the HI16 relocs. Now deal with the LO16.
4e6a05fe TS	186	*/
	187	val = v + vallo;
	188	insnlo = (insnlo & ~0xffff) \| (val & 0xffff);
	189	*location = insnlo;
	190
	191	return 0;
	192
	193	out_danger:
c54de490 RB	194	free_relocation_chain(l);
c54de490 RB	195	me->arch.r_mips_hi16_list = NULL;
d3cac35c	196
430d0b88	197	pr_err("module %s: dangerous R_MIPS_LO16 relocation\n", me->name);
4e6a05fe TS	198
	199	return -ENOEXEC;
	200	}
	201
430d0b88 PB	202	static int apply_r_mips_pc(struct module me, u32 location, u32 base,
430d0b88 PB	203	Elf_Addr v, unsigned int bits)
5d3c7925 PB	204	{
	205	unsigned long mask = GENMASK(bits - 1, 0);
	206	unsigned long se_bits;
	207	long offset;
	208
	209	if (v % 4) {
430d0b88	210	pr_err("module %s: dangerous R_MIPS_PC%u relocation\n",
5d3c7925 PB	211	me->name, bits);
	212	return -ENOEXEC;
	213	}
	214
430d0b88 PB	215	/* retrieve & sign extend implicit addend if any */
430d0b88 PB	216	offset = base & mask;
5d3c7925 PB	217	offset \|= (offset & BIT(bits - 1)) ? ~mask : 0;
	218
	219	offset += ((long)v - (long)location) >> 2;
	220
	221	/* check the sign bit onwards are identical - ie. we didn't overflow */
	222	se_bits = (offset & BIT(bits - 1)) ? ~0ul : 0;
	223	if ((offset & ~mask) != (se_bits & ~mask)) {
	224	pr_err("module %s: relocation overflow\n", me->name);
	225	return -ENOEXEC;
	226	}
	227
	228	location = (location & ~mask) \| (offset & mask);
	229
	230	return 0;
	231	}
	232
430d0b88 PB	233	static int apply_r_mips_pc16(struct module me, u32 location,
430d0b88 PB	234	u32 base, Elf_Addr v, bool rela)
5d3c7925	235	{
430d0b88	236	return apply_r_mips_pc(me, location, base, v, 16);
5d3c7925 PB	237	}
5d3c7925 PB	238
430d0b88 PB	239	static int apply_r_mips_pc21(struct module me, u32 location,
430d0b88 PB	240	u32 base, Elf_Addr v, bool rela)
5d3c7925	241	{
430d0b88	242	return apply_r_mips_pc(me, location, base, v, 21);
5d3c7925 PB	243	}
5d3c7925 PB	244
430d0b88 PB	245	static int apply_r_mips_pc26(struct module me, u32 location,
430d0b88 PB	246	u32 base, Elf_Addr v, bool rela)
5d3c7925	247	{
430d0b88	248	return apply_r_mips_pc(me, location, base, v, 26);
5d3c7925 PB	249	}
5d3c7925 PB	250
430d0b88 PB	251	static int apply_r_mips_64(struct module me, u32 location,
430d0b88 PB	252	u32 base, Elf_Addr v, bool rela)
5d3c7925	253	{
430d0b88 PB	254	if (WARN_ON(!rela))
	255	return -EINVAL;
	256
	257	(Elf_Addr )location = v;
	258
	259	return 0;
5d3c7925 PB	260	}
5d3c7925 PB	261
430d0b88 PB	262	static int apply_r_mips_higher(struct module me, u32 location,
430d0b88 PB	263	u32 base, Elf_Addr v, bool rela)
5d3c7925	264	{
430d0b88 PB	265	if (WARN_ON(!rela))
	266	return -EINVAL;
	267
	268	location = (location & 0xffff0000) \|
	269	((((long long)v + 0x80008000LL) >> 32) & 0xffff);
	270
	271	return 0;
5d3c7925 PB	272	}
5d3c7925 PB	273
430d0b88 PB	274	static int apply_r_mips_highest(struct module me, u32 location,
430d0b88 PB	275	u32 base, Elf_Addr v, bool rela)
5d3c7925	276	{
430d0b88 PB	277	if (WARN_ON(!rela))
	278	return -EINVAL;
	279
	280	location = (location & 0xffff0000) \|
	281	((((long long)v + 0x800080008000LL) >> 48) & 0xffff);
	282
	283	return 0;
5d3c7925 PB	284	}
5d3c7925 PB	285
430d0b88 PB	286	/**
	287	* reloc_handler() - Apply a particular relocation to a module
	288	* @me: the module to apply the reloc to
	289	* @location: the address at which the reloc is to be applied
	290	* @base: the existing value at location for REL-style; 0 for RELA-style
	291	* @v: the value of the reloc, with addend for RELA-style
	292	*
	293	* Each implemented reloc_handler function applies a particular type of
	294	* relocation to the module @me. Relocs that may be found in either REL or RELA
	295	* variants can be handled by making use of the @base & @v parameters which are
	296	* set to values which abstract the difference away from the particular reloc
	297	* implementations.
	298	*
	299	* Return: 0 upon success, else -ERRNO
	300	*/
	301	typedef int (reloc_handler)(struct module me, u32 *location,
	302	u32 base, Elf_Addr v, bool rela);
	303
	304	/* The handlers for known reloc types */
	305	static reloc_handler reloc_handlers[] = {
4e6a05fe	306	[R_MIPS_NONE] = apply_r_mips_none,
430d0b88 PB	307	[R_MIPS_32] = apply_r_mips_32,
	308	[R_MIPS_26] = apply_r_mips_26,
	309	[R_MIPS_HI16] = apply_r_mips_hi16,
	310	[R_MIPS_LO16] = apply_r_mips_lo16,
	311	[R_MIPS_PC16] = apply_r_mips_pc16,
	312	[R_MIPS_64] = apply_r_mips_64,
	313	[R_MIPS_HIGHER] = apply_r_mips_higher,
	314	[R_MIPS_HIGHEST] = apply_r_mips_highest,
	315	[R_MIPS_PC21_S2] = apply_r_mips_pc21,
	316	[R_MIPS_PC26_S2] = apply_r_mips_pc26,
4e6a05fe TS	317	};
4e6a05fe TS	318
430d0b88 PB	319	static int __apply_relocate(Elf_Shdr sechdrs, const char strtab,
	320	unsigned int symindex, unsigned int relsec,
	321	struct module *me, bool rela)
4e6a05fe	322	{
430d0b88 PB	323	union {
	324	Elf_Mips_Rel *rel;
	325	Elf_Mips_Rela *rela;
	326	} r;
	327	reloc_handler handler;
4e6a05fe	328	Elf_Sym *sym;
430d0b88	329	u32 *location, base;
04211a57	330	unsigned int i, type;
4e6a05fe	331	Elf_Addr v;
351b0940	332	int err = 0;
430d0b88	333	size_t reloc_sz;
4e6a05fe TS	334
	335	pr_debug("Applying relocate section %u to %u\n", relsec,
	336	sechdrs[relsec].sh_info);
	337
430d0b88 PB	338	r.rel = (void *)sechdrs[relsec].sh_addr;
430d0b88 PB	339	reloc_sz = rela ? sizeof(r.rela) : sizeof(r.rel);
861667dc	340	me->arch.r_mips_hi16_list = NULL;
430d0b88	341	for (i = 0; i < sechdrs[relsec].sh_size / reloc_sz; i++) {
4e6a05fe TS	342	/* This is where to make the change */
4e6a05fe TS	343	location = (void *)sechdrs[sechdrs[relsec].sh_info].sh_addr
430d0b88	344	+ r.rel->r_offset;
4e6a05fe TS	345	/* This is the symbol it is referring to */
4e6a05fe TS	346	sym = (Elf_Sym *)sechdrs[symindex].sh_addr
430d0b88	347	+ ELF_MIPS_R_SYM(*r.rel);
ba837d38	348	if (sym->st_value >= -MAX_ERRNO) {
f3bf07b9 AN	349	/* Ignore unresolved weak symbol */
	350	if (ELF_ST_BIND(sym->st_info) == STB_WEAK)
	351	continue;
55d791f3 SH	352	pr_warn("%s: Unknown symbol %s\n",
55d791f3 SH	353	me->name, strtab + sym->st_name);
351b0940 PB	354	err = -ENOENT;
351b0940 PB	355	goto out;
4e6a05fe TS	356	}
4e6a05fe TS	357
430d0b88 PB	358	type = ELF_MIPS_R_TYPE(*r.rel);
	359	if (type < ARRAY_SIZE(reloc_handlers))
	360	handler = reloc_handlers[type];
04211a57 PB	361	else
04211a57 PB	362	handler = NULL;
4e6a05fe	363
04211a57 PB	364	if (!handler) {
	365	pr_err("%s: Unknown relocation type %u\n",
	366	me->name, type);
351b0940 PB	367	err = -EINVAL;
351b0940 PB	368	goto out;
04211a57 PB	369	}
04211a57 PB	370
430d0b88 PB	371	if (rela) {
	372	v = sym->st_value + r.rela->r_addend;
	373	base = 0;
	374	r.rela = &r.rela[1];
	375	} else {
	376	v = sym->st_value;
	377	base = *location;
	378	r.rel = &r.rel[1];
	379	}
	380
	381	err = handler(me, location, base, v, rela);
351b0940 PB	382	if (err)
351b0940 PB	383	goto out;
4e6a05fe TS	384	}
4e6a05fe TS	385
351b0940	386	out:
c54de490	387	/*
351b0940	388	* Normally the hi16 list should be deallocated at this point. A
c54de490	389	* malformed binary however could contain a series of R_MIPS_HI16
351b0940 PB	390	* relocations not followed by a R_MIPS_LO16 relocation, or if we hit
	391	* an error processing a reloc we might have gotten here before
	392	* reaching the R_MIPS_LO16. In either case, free up the list and
	393	* return an error.
c54de490 RB	394	*/
	395	if (me->arch.r_mips_hi16_list) {
	396	free_relocation_chain(me->arch.r_mips_hi16_list);
	397	me->arch.r_mips_hi16_list = NULL;
351b0940	398	err = err ?: -ENOEXEC;
c54de490 RB	399	}
c54de490 RB	400
351b0940	401	return err;
4e6a05fe TS	402	}
4e6a05fe TS	403
430d0b88 PB	404	int apply_relocate(Elf_Shdr sechdrs, const char strtab,
	405	unsigned int symindex, unsigned int relsec,
	406	struct module *me)
	407	{
	408	return __apply_relocate(sechdrs, strtab, symindex, relsec, me, false);
	409	}
	410
	411	#ifdef CONFIG_MODULES_USE_ELF_RELA
	412	int apply_relocate_add(Elf_Shdr sechdrs, const char strtab,
	413	unsigned int symindex, unsigned int relsec,
	414	struct module *me)
	415	{
	416	return __apply_relocate(sechdrs, strtab, symindex, relsec, me, true);
4e6a05fe	417	}
430d0b88	418	#endif /* CONFIG_MODULES_USE_ELF_RELA */
4e6a05fe	419
1da177e4 LT	420	/* Given an address, look for it in the module exception tables. */
	421	const struct exception_table_entry *search_module_dbetables(unsigned long addr)
	422	{
	423	unsigned long flags;
	424	const struct exception_table_entry *e = NULL;
	425	struct mod_arch_specific *dbe;
	426
	427	spin_lock_irqsave(&dbe_lock, flags);
	428	list_for_each_entry(dbe, &dbe_list, dbe_list) {
a94c33dd TM	429	e = search_extable(dbe->dbe_start,
a94c33dd TM	430	dbe->dbe_end - dbe->dbe_start, addr);
1da177e4 LT	431	if (e)
	432	break;
	433	}
	434	spin_unlock_irqrestore(&dbe_lock, flags);
	435
	436	/* Now, if we found one, we are running inside it now, hence
70342287	437	we cannot unload the module, hence no refcnt needed. */
1da177e4 LT	438	return e;
	439	}
	440
3a4fa0a2	441	/* Put in dbe list if necessary. */
1da177e4 LT	442	int module_finalize(const Elf_Ehdr *hdr,
	443	const Elf_Shdr *sechdrs,
	444	struct module *me)
	445	{
	446	const Elf_Shdr *s;
	447	char secstrings = (void )hdr + sechdrs[hdr->e_shstrndx].sh_offset;
	448
94bb0c1a DD	449	/* Make jump label nops. */
	450	jump_label_apply_nops(me);
	451
1da177e4 LT	452	INIT_LIST_HEAD(&me->arch.dbe_list);
	453	for (s = sechdrs; s < sechdrs + hdr->e_shnum; s++) {
	454	if (strcmp("__dbe_table", secstrings + s->sh_name) != 0)
	455	continue;
	456	me->arch.dbe_start = (void *)s->sh_addr;
	457	me->arch.dbe_end = (void *)s->sh_addr + s->sh_size;
	458	spin_lock_irq(&dbe_lock);
	459	list_add(&me->arch.dbe_list, &dbe_list);
	460	spin_unlock_irq(&dbe_lock);
	461	}
	462	return 0;
	463	}
	464
	465	void module_arch_cleanup(struct module *mod)
	466	{
	467	spin_lock_irq(&dbe_lock);
	468	list_del(&mod->arch.dbe_list);
	469	spin_unlock_irq(&dbe_lock);
	470	}