1 files changed, 336 insertions, 0 deletions
diff --git a/arch/mips/kernel/module.c b/arch/mips/kernel/module.c
index 458af3c7a639..e54a7f442f8a 100644
--- a/arch/mips/kernel/module.c
+++ b/arch/mips/kernel/module.c
@@ -1,9 +1,345 @@
+/*
+ *  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/moduleloader.h>
+#include <linux/elf.h>
+#include <linux/vmalloc.h>
+#include <linux/slab.h>
+#include <linux/fs.h>
+#include <linux/string.h>
+#include <linux/kernel.h>
 #include <linux/module.h>
 #include <linux/spinlock.h>
+struct mips_hi16 {
+        struct mips_hi16 *next;
+        Elf_Addr *addr;
+        Elf_Addr value;
+};
+static struct mips_hi16 *mips_hi16_list;
 static LIST_HEAD(dbe_list);
 static DEFINE_SPINLOCK(dbe_lock);
+void *module_alloc(unsigned long size)
+{
+        if (size == 0)
+                return NULL;
+        return vmalloc(size);
+}
+/* Free memory returned from module_alloc */
+void module_free(struct module *mod, void *module_region)
+{
+        vfree(module_region);
+        /* FIXME: If module_region == mod->init_region, trim exception
+           table entries. */
+}
+int module_frob_arch_sections(Elf_Ehdr *hdr, Elf_Shdr *sechdrs,
+                              char *secstrings, struct module *mod)
+{
+        return 0;
+}
+static int apply_r_mips_none(struct module *me, u32 *location, Elf_Addr v)
+{
+        return 0;
+}
+static int apply_r_mips_32_rel(struct module *me, u32 *location, Elf_Addr v)
+{
+        *location += v;
+        return 0;
+}
+static int apply_r_mips_32_rela(struct module *me, u32 *location, Elf_Addr v)
+{
+        *location = v;
+        return 0;
+}
+static int apply_r_mips_26_rel(struct module *me, u32 *location, Elf_Addr v)
+{
+        if (v % 4) {
+                printk(KERN_ERR "module %s: dangerous relocation\n", me->name);
+                return -ENOEXEC;
+        }
+        if ((v & 0xf0000000) != (((unsigned long)location + 4) & 0xf0000000)) {
+                printk(KERN_ERR
+                       "module %s: relocation overflow\n",
+                       me->name);
+                return -ENOEXEC;
+        }
+        *location = (*location & ~0x03ffffff) |
+                    ((*location + (v >> 2)) & 0x03ffffff);
+        return 0;
+}
+static int apply_r_mips_26_rela(struct module *me, u32 *location, Elf_Addr v)
+{
+        if (v % 4) {
+                printk(KERN_ERR "module %s: dangerous relocation\n", me->name);
+                return -ENOEXEC;
+        }
+        if ((v & 0xf0000000) != (((unsigned long)location + 4) & 0xf0000000)) {
+                printk(KERN_ERR
+                       "module %s: relocation overflow\n",
+                       me->name);
+                return -ENOEXEC;
+        }
+        *location = (*location & ~0x03ffffff) | ((v >> 2) & 0x03ffffff);
+        return 0;
+}
+static int apply_r_mips_hi16_rel(struct module *me, u32 *location, Elf_Addr v)
+{
+        struct mips_hi16 *n;
+        /*
+         * 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 = mips_hi16_list;
+        mips_hi16_list = n;
+        return 0;
+}
+static int apply_r_mips_hi16_rela(struct module *me, u32 *location, Elf_Addr v)
+{
+        *location = (*location & 0xffff0000) |
+                    ((((long long) v + 0x8000LL) >> 16) & 0xffff);
+        return 0;
+}
+static int apply_r_mips_lo16_rel(struct module *me, u32 *location, Elf_Addr v)
+{
+        unsigned long insnlo = *location;
+        Elf_Addr val, vallo;
+        /* Sign extend the addend we extract from the lo insn.  */
+        vallo = ((insnlo & 0xffff) ^ 0x8000) - 0x8000;
+        if (mips_hi16_list != NULL) {
+                struct mips_hi16 *l;
+                l = 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;
+                }
+                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:
+        printk(KERN_ERR "module %s: dangerous " "relocation\n", me->name);
+        return -ENOEXEC;
+}
+static int apply_r_mips_lo16_rela(struct module *me, u32 *location, Elf_Addr v)
+{
+        *location = (*location & 0xffff0000) | (v & 0xffff);
+        return 0;
+}
+static int apply_r_mips_64_rela(struct module *me, u32 *location, Elf_Addr v)
+{
+        *(Elf_Addr *)location = v;
+        return 0;
+}
+static int apply_r_mips_higher_rela(struct module *me, u32 *location,
+                                    Elf_Addr v)
+{
+        *location = (*location & 0xffff0000) |
+                    ((((long long) v + 0x80008000LL) >> 32) & 0xffff);
+        return 0;
+}
+static int apply_r_mips_highest_rela(struct module *me, u32 *location,
+                                     Elf_Addr v)
+{
+        *location = (*location & 0xffff0000) |
+                    ((((long long) v + 0x800080008000LL) >> 48) & 0xffff);
+        return 0;
+}
+static int (*reloc_handlers_rel[]) (struct module *me, u32 *location,
+                                Elf_Addr v) = {
+        [R_MIPS_NONE]           = apply_r_mips_none,
+        [R_MIPS_32]             = apply_r_mips_32_rel,
+        [R_MIPS_26]             = apply_r_mips_26_rel,
+        [R_MIPS_HI16]           = apply_r_mips_hi16_rel,
+        [R_MIPS_LO16]           = apply_r_mips_lo16_rel
+};
+static int (*reloc_handlers_rela[]) (struct module *me, u32 *location,
+                                Elf_Addr v) = {
+        [R_MIPS_NONE]           = apply_r_mips_none,
+        [R_MIPS_32]             = apply_r_mips_32_rela,
+        [R_MIPS_26]             = apply_r_mips_26_rela,
+        [R_MIPS_HI16]           = apply_r_mips_hi16_rela,
+        [R_MIPS_LO16]           = apply_r_mips_lo16_rela,
+        [R_MIPS_64]             = apply_r_mips_64_rela,
+        [R_MIPS_HIGHER]         = apply_r_mips_higher_rela,
+        [R_MIPS_HIGHEST]        = apply_r_mips_highest_rela
+};
+int apply_relocate(Elf_Shdr *sechdrs, const char *strtab,
+                   unsigned int symindex, unsigned int relsec,
+                   struct module *me)
+{
+        Elf_Mips_Rel *rel = (void *) sechdrs[relsec].sh_addr;
+        Elf_Sym *sym;
+        u32 *location;
+        unsigned int i;
+        Elf_Addr v;
+        int res;
+        pr_debug("Applying relocate section %u to %u\n", relsec,
+               sechdrs[relsec].sh_info);
+        for (i = 0; i < sechdrs[relsec].sh_size / sizeof(*rel); i++) {
+                /* This is where to make the change */
+                location = (void *)sechdrs[sechdrs[relsec].sh_info].sh_addr
+                        + rel[i].r_offset;
+                /* This is the symbol it is referring to */
+                sym = (Elf_Sym *)sechdrs[symindex].sh_addr
+                        + ELF_MIPS_R_SYM(rel[i]);
+                if (!sym->st_value) {
+                        printk(KERN_WARNING "%s: Unknown symbol %s\n",
+                               me->name, strtab + sym->st_name);
+                        return -ENOENT;
+                }
+                v = sym->st_value;
+                res = reloc_handlers_rel[ELF_MIPS_R_TYPE(rel[i])](me, location, v);
+                if (res)
+                        return res;
+        }
+        return 0;
+}
+int apply_relocate_add(Elf_Shdr *sechdrs, const char *strtab,
+                       unsigned int symindex, unsigned int relsec,
+                       struct module *me)
+{
+        Elf_Mips_Rela *rel = (void *) sechdrs[relsec].sh_addr;
+        Elf_Sym *sym;
+        u32 *location;
+        unsigned int i;
+        Elf_Addr v;
+        int res;
+        pr_debug("Applying relocate section %u to %u\n", relsec,
+               sechdrs[relsec].sh_info);
+        for (i = 0; i < sechdrs[relsec].sh_size / sizeof(*rel); i++) {
+                /* This is where to make the change */
+                location = (void *)sechdrs[sechdrs[relsec].sh_info].sh_addr
+                        + rel[i].r_offset;
+                /* This is the symbol it is referring to */
+                sym = (Elf_Sym *)sechdrs[symindex].sh_addr
+                        + ELF_MIPS_R_SYM(rel[i]);
+                if (!sym->st_value) {
+                        printk(KERN_WARNING "%s: Unknown symbol %s\n",
+                               me->name, strtab + sym->st_name);
+                        return -ENOENT;
+                }
+                v = sym->st_value + rel[i].r_addend;
+                res = reloc_handlers_rela[ELF_MIPS_R_TYPE(rel[i])](me, location, v);
+                if (res)
+                        return res;
+        }
+        return 0;
+}
 /* Given an address, look for it in the module exception tables. */
 const struct exception_table_entry *search_module_dbetables(unsigned long addr)
 {

diff --git a/arch/mips/kernel/module.c b/arch/mips/kernel/module.c index 458af3c7a639..e54a7f442f8a 100644 --- a/arch/mips/kernel/module.c +++ b/arch/mips/kernel/module.c
@@ -1,9 +1,345 @@
		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
		23	#include <linux/moduleloader.h>
		24	#include <linux/elf.h>
		25	#include <linux/vmalloc.h>
		26	#include <linux/slab.h>
		27	#include <linux/fs.h>
		28	#include <linux/string.h>
		29	#include <linux/kernel.h>
1	#include <linux/module.h>	30	#include <linux/module.h>
2	#include <linux/spinlock.h>	31	#include <linux/spinlock.h>
3		32
		33	struct mips_hi16 {
		34	struct mips_hi16 *next;
		35	Elf_Addr *addr;
		36	Elf_Addr value;
		37	};
		38
		39	static struct mips_hi16 *mips_hi16_list;
		40
4	static LIST_HEAD(dbe_list);	41	static LIST_HEAD(dbe_list);
5	static DEFINE_SPINLOCK(dbe_lock);	42	static DEFINE_SPINLOCK(dbe_lock);
6		43
		44	void *module_alloc(unsigned long size)
		45	{
		46	if (size == 0)
		47	return NULL;
		48	return vmalloc(size);
		49	}
		50
		51	/* Free memory returned from module_alloc */
		52	void module_free(struct module mod, void module_region)
		53	{
		54	vfree(module_region);
		55	/* FIXME: If module_region == mod->init_region, trim exception
		56	table entries. */
		57	}
		58
		59	int module_frob_arch_sections(Elf_Ehdr hdr, Elf_Shdr sechdrs,
		60	char secstrings, struct module mod)
		61	{
		62	return 0;
		63	}
		64
		65	static int apply_r_mips_none(struct module me, u32 location, Elf_Addr v)
		66	{
		67	return 0;
		68	}
		69
		70	static int apply_r_mips_32_rel(struct module me, u32 location, Elf_Addr v)
		71	{
		72	*location += v;
		73
		74	return 0;
		75	}
		76
		77	static int apply_r_mips_32_rela(struct module me, u32 location, Elf_Addr v)
		78	{
		79	*location = v;
		80
		81	return 0;
		82	}
		83
		84	static int apply_r_mips_26_rel(struct module me, u32 location, Elf_Addr v)
		85	{
		86	if (v % 4) {
		87	printk(KERN_ERR "module %s: dangerous relocation\n", me->name);
		88	return -ENOEXEC;
		89	}
		90
		91	if ((v & 0xf0000000) != (((unsigned long)location + 4) & 0xf0000000)) {
		92	printk(KERN_ERR
		93	"module %s: relocation overflow\n",
		94	me->name);
		95	return -ENOEXEC;
		96	}
		97
		98	location = (location & ~0x03ffffff) \|
		99	((*location + (v >> 2)) & 0x03ffffff);
		100
		101	return 0;
		102	}
		103
		104	static int apply_r_mips_26_rela(struct module me, u32 location, Elf_Addr v)
		105	{
		106	if (v % 4) {
		107	printk(KERN_ERR "module %s: dangerous relocation\n", me->name);
		108	return -ENOEXEC;
		109	}
		110
		111	if ((v & 0xf0000000) != (((unsigned long)location + 4) & 0xf0000000)) {
		112	printk(KERN_ERR
		113	"module %s: relocation overflow\n",
		114	me->name);
		115	return -ENOEXEC;
		116	}
		117
		118	location = (location & ~0x03ffffff) \| ((v >> 2) & 0x03ffffff);
		119
		120	return 0;
		121	}
		122
		123	static int apply_r_mips_hi16_rel(struct module me, u32 location, Elf_Addr v)
		124	{
		125	struct mips_hi16 *n;
		126
		127	/*
		128	* We cannot relocate this one now because we don't know the value of
		129	* the carry we need to add. Save the information, and let LO16 do the
		130	* actual relocation.
		131	*/
		132	n = kmalloc(sizeof *n, GFP_KERNEL);
		133	if (!n)
		134	return -ENOMEM;
		135
		136	n->addr = (Elf_Addr *)location;
		137	n->value = v;
		138	n->next = mips_hi16_list;
		139	mips_hi16_list = n;
		140
		141	return 0;
		142	}
		143
		144	static int apply_r_mips_hi16_rela(struct module me, u32 location, Elf_Addr v)
		145	{
		146	location = (location & 0xffff0000) \|
		147	((((long long) v + 0x8000LL) >> 16) & 0xffff);
		148
		149	return 0;
		150	}
		151
		152	static int apply_r_mips_lo16_rel(struct module me, u32 location, Elf_Addr v)
		153	{
		154	unsigned long insnlo = *location;
		155	Elf_Addr val, vallo;
		156
		157	/* Sign extend the addend we extract from the lo insn. */
		158	vallo = ((insnlo & 0xffff) ^ 0x8000) - 0x8000;
		159
		160	if (mips_hi16_list != NULL) {
		161	struct mips_hi16 *l;
		162
		163	l = mips_hi16_list;
		164	while (l != NULL) {
		165	struct mips_hi16 *next;
		166	unsigned long insn;
		167
		168	/*
		169	* The value for the HI16 had best be the same.
		170	*/
		171	if (v != l->value)
		172	goto out_danger;
		173
		174	/*
		175	* Do the HI16 relocation. Note that we actually don't
		176	* need to know anything about the LO16 itself, except
		177	* where to find the low 16 bits of the addend needed
		178	* by the LO16.
		179	*/
		180	insn = *l->addr;
		181	val = ((insn & 0xffff) << 16) + vallo;
		182	val += v;
		183
		184	/*
		185	* Account for the sign extension that will happen in
		186	* the low bits.
		187	*/
		188	val = ((val >> 16) + ((val & 0x8000) != 0)) & 0xffff;
		189
		190	insn = (insn & ~0xffff) \| val;
		191	*l->addr = insn;
		192
		193	next = l->next;
		194	kfree(l);
		195	l = next;
		196	}
		197
		198	mips_hi16_list = NULL;
		199	}
		200
		201	/*
		202	* Ok, we're done with the HI16 relocs. Now deal with the LO16.
		203	*/
		204	val = v + vallo;
		205	insnlo = (insnlo & ~0xffff) \| (val & 0xffff);
		206	*location = insnlo;
		207
		208	return 0;
		209
		210	out_danger:
		211	printk(KERN_ERR "module %s: dangerous " "relocation\n", me->name);
		212
		213	return -ENOEXEC;
		214	}
		215
		216	static int apply_r_mips_lo16_rela(struct module me, u32 location, Elf_Addr v)
		217	{
		218	location = (location & 0xffff0000) \| (v & 0xffff);
		219
		220	return 0;
		221	}
		222
		223	static int apply_r_mips_64_rela(struct module me, u32 location, Elf_Addr v)
		224	{
		225	(Elf_Addr )location = v;
		226
		227	return 0;
		228	}
		229
		230	static int apply_r_mips_higher_rela(struct module me, u32 location,
		231	Elf_Addr v)
		232	{
		233	location = (location & 0xffff0000) \|
		234	((((long long) v + 0x80008000LL) >> 32) & 0xffff);
		235
		236	return 0;
		237	}
		238
		239	static int apply_r_mips_highest_rela(struct module me, u32 location,
		240	Elf_Addr v)
		241	{
		242	location = (location & 0xffff0000) \|
		243	((((long long) v + 0x800080008000LL) >> 48) & 0xffff);
		244
		245	return 0;
		246	}
		247
		248	static int (reloc_handlers_rel[]) (struct module me, u32 *location,
		249	Elf_Addr v) = {
		250	[R_MIPS_NONE] = apply_r_mips_none,
		251	[R_MIPS_32] = apply_r_mips_32_rel,
		252	[R_MIPS_26] = apply_r_mips_26_rel,
		253	[R_MIPS_HI16] = apply_r_mips_hi16_rel,
		254	[R_MIPS_LO16] = apply_r_mips_lo16_rel
		255	};
		256
		257	static int (reloc_handlers_rela[]) (struct module me, u32 *location,
		258	Elf_Addr v) = {
		259	[R_MIPS_NONE] = apply_r_mips_none,
		260	[R_MIPS_32] = apply_r_mips_32_rela,
		261	[R_MIPS_26] = apply_r_mips_26_rela,
		262	[R_MIPS_HI16] = apply_r_mips_hi16_rela,
		263	[R_MIPS_LO16] = apply_r_mips_lo16_rela,
		264	[R_MIPS_64] = apply_r_mips_64_rela,
		265	[R_MIPS_HIGHER] = apply_r_mips_higher_rela,
		266	[R_MIPS_HIGHEST] = apply_r_mips_highest_rela
		267	};
		268
		269	int apply_relocate(Elf_Shdr sechdrs, const char strtab,
		270	unsigned int symindex, unsigned int relsec,
		271	struct module *me)
		272	{
		273	Elf_Mips_Rel rel = (void ) sechdrs[relsec].sh_addr;
		274	Elf_Sym *sym;
		275	u32 *location;
		276	unsigned int i;
		277	Elf_Addr v;
		278	int res;
		279
		280	pr_debug("Applying relocate section %u to %u\n", relsec,
		281	sechdrs[relsec].sh_info);
		282
		283	for (i = 0; i < sechdrs[relsec].sh_size / sizeof(*rel); i++) {
		284	/* This is where to make the change */
		285	location = (void *)sechdrs[sechdrs[relsec].sh_info].sh_addr
		286	+ rel[i].r_offset;
		287	/* This is the symbol it is referring to */
		288	sym = (Elf_Sym *)sechdrs[symindex].sh_addr
		289	+ ELF_MIPS_R_SYM(rel[i]);
		290	if (!sym->st_value) {
		291	printk(KERN_WARNING "%s: Unknown symbol %s\n",
		292	me->name, strtab + sym->st_name);
		293	return -ENOENT;
		294	}
		295
		296	v = sym->st_value;
		297
		298	res = reloc_handlers_rel[ELF_MIPS_R_TYPE(rel[i])](me, location, v);
		299	if (res)
		300	return res;
		301	}
		302
		303	return 0;
		304	}
		305
		306	int apply_relocate_add(Elf_Shdr sechdrs, const char strtab,
		307	unsigned int symindex, unsigned int relsec,
		308	struct module *me)
		309	{
		310	Elf_Mips_Rela rel = (void ) sechdrs[relsec].sh_addr;
		311	Elf_Sym *sym;
		312	u32 *location;
		313	unsigned int i;
		314	Elf_Addr v;
		315	int res;
		316
		317	pr_debug("Applying relocate section %u to %u\n", relsec,
		318	sechdrs[relsec].sh_info);
		319
		320	for (i = 0; i < sechdrs[relsec].sh_size / sizeof(*rel); i++) {
		321	/* This is where to make the change */
		322	location = (void *)sechdrs[sechdrs[relsec].sh_info].sh_addr
		323	+ rel[i].r_offset;
		324	/* This is the symbol it is referring to */
		325	sym = (Elf_Sym *)sechdrs[symindex].sh_addr
		326	+ ELF_MIPS_R_SYM(rel[i]);
		327	if (!sym->st_value) {
		328	printk(KERN_WARNING "%s: Unknown symbol %s\n",
		329	me->name, strtab + sym->st_name);
		330	return -ENOENT;
		331	}
		332
		333	v = sym->st_value + rel[i].r_addend;
		334
		335	res = reloc_handlers_rela[ELF_MIPS_R_TYPE(rel[i])](me, location, v);
		336	if (res)
		337	return res;
		338	}
		339
		340	return 0;
		341	}
		342
7	/* Given an address, look for it in the module exception tables. */	343	/* Given an address, look for it in the module exception tables. */
8	const struct exception_table_entry *search_module_dbetables(unsigned long addr)	344	const struct exception_table_entry *search_module_dbetables(unsigned long addr)
9	{	345	{