[linux.git] / arch / hexagon / kernel / module.c

/*
 * Kernel module loader for Hexagon
 *
 * Copyright (c) 2010-2011, The Linux Foundation. All rights reserved.
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License version 2 and
 * only version 2 as published by the Free Software Foundation.
 *
 * 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., 51 Franklin Street, Fifth Floor, Boston, MA
 * 02110-1301, USA.
 */

#include <asm/module.h>
#include <linux/elf.h>
#include <linux/module.h>
#include <linux/moduleloader.h>
#include <linux/vmalloc.h>

#if 0
#define DEBUGP printk
#else
#define DEBUGP(fmt , ...)
#endif

/*
 * module_frob_arch_sections - tweak got/plt sections.
 * @hdr - pointer to elf header
 * @sechdrs - pointer to elf load section headers
 * @secstrings - symbol names
 * @mod - pointer to module
 */
int module_frob_arch_sections(Elf_Ehdr *hdr, Elf_Shdr *sechdrs,
				char *secstrings,
				struct module *mod)
{
	unsigned int i;
	int found = 0;

	/* Look for .plt and/or .got.plt and/or .init.plt sections */
	for (i = 0; i < hdr->e_shnum; i++) {
		DEBUGP("Section %d is %s\n", i,
		       secstrings + sechdrs[i].sh_name);
		if (strcmp(secstrings + sechdrs[i].sh_name, ".plt") == 0)
			found = i+1;
		if (strcmp(secstrings + sechdrs[i].sh_name, ".got.plt") == 0)
			found = i+1;
		if (strcmp(secstrings + sechdrs[i].sh_name, ".rela.plt") == 0)
			found = i+1;
	}

	/* At this time, we don't support modules comiled with -shared */
	if (found) {
		printk(KERN_WARNING
			"Module '%s' contains unexpected .plt/.got sections.\n",
			mod->name);
		/*  return -ENOEXEC;  */
	}

	return 0;
}

/*
 * apply_relocate_add - perform rela relocations.
 * @sechdrs - pointer to section headers
 * @strtab - some sort of start address?
 * @symindex - symbol index offset or something?
 * @relsec - address to relocate to?
 * @module - pointer to module
 *
 * Perform rela relocations.
 */
int apply_relocate_add(Elf_Shdr *sechdrs, const char *strtab,
			unsigned int symindex, unsigned int relsec,
			struct module *module)
{
	unsigned int i;
	Elf32_Sym *sym;
	uint32_t *location;
	uint32_t value;
	unsigned int nrelocs = sechdrs[relsec].sh_size / sizeof(Elf32_Rela);
	Elf32_Rela *rela = (void *)sechdrs[relsec].sh_addr;
	Elf32_Word sym_info = sechdrs[relsec].sh_info;
	Elf32_Sym *sym_base = (Elf32_Sym *) sechdrs[symindex].sh_addr;
	void *loc_base = (void *) sechdrs[sym_info].sh_addr;

	DEBUGP("Applying relocations in section %u to section %u base=%p\n",
	       relsec, sym_info, loc_base);

	for (i = 0; i < nrelocs; i++) {

		/* Symbol to relocate */
		sym = sym_base + ELF32_R_SYM(rela[i].r_info);

		/* Where to make the change */
		location = loc_base + rela[i].r_offset;

		/* `Everything is relative'. */
		value = sym->st_value + rela[i].r_addend;

		DEBUGP("%d: value=%08x loc=%p reloc=%d symbol=%s\n",
		       i, value, location, ELF32_R_TYPE(rela[i].r_info),
		       sym->st_name ?
		       &strtab[sym->st_name] : "(anonymous)");

		switch (ELF32_R_TYPE(rela[i].r_info)) {
		case R_HEXAGON_B22_PCREL: {
			int dist = (int)(value - (uint32_t)location);
			if ((dist < -0x00800000) ||
			    (dist >= 0x00800000)) {
				printk(KERN_ERR
				       "%s: %s: %08x=%08x-%08x %s\n",
				       module->name,
				       "R_HEXAGON_B22_PCREL reloc out of range",
				       dist, value, (uint32_t)location,
				       sym->st_name ?
				       &strtab[sym->st_name] : "(anonymous)");
				return -ENOEXEC;
			}
			DEBUGP("B22_PCREL contents: %08X.\n", *location);
			*location &= ~0x01ff3fff;
			*location |= 0x00003fff & dist;
			*location |= 0x01ff0000 & (dist<<2);
			DEBUGP("Contents after reloc: %08x\n", *location);
			break;
		}
		case R_HEXAGON_HI16:
			value = (value>>16) & 0xffff;
			/* fallthrough */
		case R_HEXAGON_LO16:
			*location &= ~0x00c03fff;
			*location |= value & 0x3fff;
			*location |= (value & 0xc000) << 8;
			break;
		case R_HEXAGON_32:
			*location = value;
			break;
		case R_HEXAGON_32_PCREL:
			*location = value - (uint32_t)location;
			break;
		case R_HEXAGON_PLT_B22_PCREL:
		case R_HEXAGON_GOTOFF_LO16:
		case R_HEXAGON_GOTOFF_HI16:
			printk(KERN_ERR "%s: GOT/PLT relocations unsupported\n",
			       module->name);
			return -ENOEXEC;
		default:
			printk(KERN_ERR "%s: unknown relocation: %u\n",
			       module->name,
			       ELF32_R_TYPE(rela[i].r_info));
			return -ENOEXEC;
		}
	}
	return 0;
}
Commit	Line	Data
98fb1036 LV	1	/*
	2	* Kernel module loader for Hexagon
	3	*
e1858b2a	4	* Copyright (c) 2010-2011, The Linux Foundation. All rights reserved.
98fb1036 LV	5	*
	6	* This program is free software; you can redistribute it and/or modify
	7	* it under the terms of the GNU General Public License version 2 and
	8	* only version 2 as published by the Free Software Foundation.
	9	*
	10	* This program is distributed in the hope that it will be useful,
	11	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	12	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	13	* GNU General Public License for more details.
	14	*
	15	* You should have received a copy of the GNU General Public License
	16	* along with this program; if not, write to the Free Software
	17	* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
	18	* 02110-1301, USA.
	19	*/
	20
	21	#include <asm/module.h>
	22	#include <linux/elf.h>
	23	#include <linux/module.h>
	24	#include <linux/moduleloader.h>
	25	#include <linux/vmalloc.h>
	26
	27	#if 0
	28	#define DEBUGP printk
	29	#else
	30	#define DEBUGP(fmt , ...)
	31	#endif
	32
	33	/*
	34	* module_frob_arch_sections - tweak got/plt sections.
	35	* @hdr - pointer to elf header
	36	* @sechdrs - pointer to elf load section headers
	37	* @secstrings - symbol names
	38	* @mod - pointer to module
	39	*/
	40	int module_frob_arch_sections(Elf_Ehdr hdr, Elf_Shdr sechdrs,
	41	char *secstrings,
	42	struct module *mod)
	43	{
	44	unsigned int i;
	45	int found = 0;
	46
	47	/* Look for .plt and/or .got.plt and/or .init.plt sections */
	48	for (i = 0; i < hdr->e_shnum; i++) {
	49	DEBUGP("Section %d is %s\n", i,
	50	secstrings + sechdrs[i].sh_name);
	51	if (strcmp(secstrings + sechdrs[i].sh_name, ".plt") == 0)
	52	found = i+1;
	53	if (strcmp(secstrings + sechdrs[i].sh_name, ".got.plt") == 0)
	54	found = i+1;
	55	if (strcmp(secstrings + sechdrs[i].sh_name, ".rela.plt") == 0)
	56	found = i+1;
	57	}
	58
	59	/* At this time, we don't support modules comiled with -shared */
	60	if (found) {
	61	printk(KERN_WARNING
	62	"Module '%s' contains unexpected .plt/.got sections.\n",
	63	mod->name);
	64	/* return -ENOEXEC; */
	65	}
	66
	67	return 0;
	68	}
69
70	/*
71	* apply_relocate_add - perform rela relocations.
72	* @sechdrs - pointer to section headers
73	* @strtab - some sort of start address?
74	* @symindex - symbol index offset or something?
75	* @relsec - address to relocate to?
76	* @module - pointer to module
77	*
78	* Perform rela relocations.
79	*/
80	int apply_relocate_add(Elf_Shdr sechdrs, const char strtab,
81	unsigned int symindex, unsigned int relsec,
82	struct module *module)
83	{
84	unsigned int i;
85	Elf32_Sym *sym;
86	uint32_t *location;
87	uint32_t value;
88	unsigned int nrelocs = sechdrs[relsec].sh_size / sizeof(Elf32_Rela);
89	Elf32_Rela rela = (void )sechdrs[relsec].sh_addr;
90	Elf32_Word sym_info = sechdrs[relsec].sh_info;
91	Elf32_Sym sym_base = (Elf32_Sym ) sechdrs[symindex].sh_addr;
92	void loc_base = (void ) sechdrs[sym_info].sh_addr;
93
94	DEBUGP("Applying relocations in section %u to section %u base=%p\n",
95	relsec, sym_info, loc_base);
96
97	for (i = 0; i < nrelocs; i++) {
98
99	/* Symbol to relocate */
100	sym = sym_base + ELF32_R_SYM(rela[i].r_info);
101
102	/* Where to make the change */
103	location = loc_base + rela[i].r_offset;
104
105	/* `Everything is relative'. */
106	value = sym->st_value + rela[i].r_addend;
107
108	DEBUGP("%d: value=%08x loc=%p reloc=%d symbol=%s\n",
109	i, value, location, ELF32_R_TYPE(rela[i].r_info),
110	sym->st_name ?
111	&strtab[sym->st_name] : "(anonymous)");
112
113	switch (ELF32_R_TYPE(rela[i].r_info)) {
114	case R_HEXAGON_B22_PCREL: {
115	int dist = (int)(value - (uint32_t)location);
116	if ((dist < -0x00800000) \|\|
117	(dist >= 0x00800000)) {
118	printk(KERN_ERR
119	"%s: %s: %08x=%08x-%08x %s\n",
120	module->name,
121	"R_HEXAGON_B22_PCREL reloc out of range",
122	dist, value, (uint32_t)location,
123	sym->st_name ?
124	&strtab[sym->st_name] : "(anonymous)");
125	return -ENOEXEC;
126	}
127	DEBUGP("B22_PCREL contents: %08X.\n", *location);
128	*location &= ~0x01ff3fff;
129	*location \|= 0x00003fff & dist;
130	*location \|= 0x01ff0000 & (dist<<2);
131	DEBUGP("Contents after reloc: %08x\n", *location);
132	break;
133	}
134	case R_HEXAGON_HI16:
135	value = (value>>16) & 0xffff;
136	/* fallthrough */
137	case R_HEXAGON_LO16:
138	*location &= ~0x00c03fff;
139	*location \|= value & 0x3fff;
140	*location \|= (value & 0xc000) << 8;
141	break;
142	case R_HEXAGON_32:
143	*location = value;
144	break;
145	case R_HEXAGON_32_PCREL:
146	*location = value - (uint32_t)location;
147	break;
148	case R_HEXAGON_PLT_B22_PCREL:
149	case R_HEXAGON_GOTOFF_LO16:
150	case R_HEXAGON_GOTOFF_HI16:
151	printk(KERN_ERR "%s: GOT/PLT relocations unsupported\n",
152	module->name);
153	return -ENOEXEC;
154	default:
155	printk(KERN_ERR "%s: unknown relocation: %u\n",
156	module->name,
157	ELF32_R_TYPE(rela[i].r_info));
158	return -ENOEXEC;
159	}
160	}
161	return 0;
162	}