[net-next-2.6.git] / arch / avr32 / kernel / module.c

/*
 * AVR32-specific kernel module loader
 *
 * Copyright (C) 2005-2006 Atmel Corporation
 *
 * GOT initialization parts are based on the s390 version
 *   Copyright (C) 2002, 2003 IBM Deutschland Entwicklung GmbH,
 *                            IBM Corporation
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License version 2 as
 * published by the Free Software Foundation.
 */

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

void *module_alloc(unsigned long size)
{
	if (size == 0)
		return NULL;
	return vmalloc(size);
}

void module_free(struct module *mod, void *module_region)
{
	vfree(mod->arch.syminfo);
	mod->arch.syminfo = NULL;

	vfree(module_region);
}

static inline int check_rela(Elf32_Rela *rela, struct module *module,
			     char *strings, Elf32_Sym *symbols)
{
	struct mod_arch_syminfo *info;

	info = module->arch.syminfo + ELF32_R_SYM(rela->r_info);
	switch (ELF32_R_TYPE(rela->r_info)) {
	case R_AVR32_GOT32:
	case R_AVR32_GOT16:
	case R_AVR32_GOT8:
	case R_AVR32_GOT21S:
	case R_AVR32_GOT18SW:	/* mcall */
	case R_AVR32_GOT16S:	/* ld.w */
		if (rela->r_addend != 0) {
			printk(KERN_ERR
			       "GOT relocation against %s at offset %u with addend\n",
			       strings + symbols[ELF32_R_SYM(rela->r_info)].st_name,
			       rela->r_offset);
			return -ENOEXEC;
		}
		if (info->got_offset == -1UL) {
			info->got_offset = module->arch.got_size;
			module->arch.got_size += sizeof(void *);
		}
		pr_debug("GOT[%3lu] %s\n", info->got_offset,
			 strings + symbols[ELF32_R_SYM(rela->r_info)].st_name);
		break;
	}

	return 0;
}

int module_frob_arch_sections(Elf_Ehdr *hdr, Elf_Shdr *sechdrs,
			      char *secstrings, struct module *module)
{
	Elf32_Shdr *symtab;
	Elf32_Sym *symbols;
	Elf32_Rela *rela;
	char *strings;
	int nrela, i, j;
	int ret;

	/* Find the symbol table */
	symtab = NULL;
	for (i = 0; i < hdr->e_shnum; i++)
		switch (sechdrs[i].sh_type) {
		case SHT_SYMTAB:
			symtab = &sechdrs[i];
			break;
		}
	if (!symtab) {
		printk(KERN_ERR "module %s: no symbol table\n", module->name);
		return -ENOEXEC;
	}

	/* Allocate room for one syminfo structure per symbol. */
	module->arch.nsyms = symtab->sh_size / sizeof(Elf_Sym);
	module->arch.syminfo = vmalloc(module->arch.nsyms
				   * sizeof(struct mod_arch_syminfo));
	if (!module->arch.syminfo)
		return -ENOMEM;

	symbols = (void *)hdr + symtab->sh_offset;
	strings = (void *)hdr + sechdrs[symtab->sh_link].sh_offset;
	for (i = 0; i < module->arch.nsyms; i++) {
		if (symbols[i].st_shndx == SHN_UNDEF &&
		    strcmp(strings + symbols[i].st_name,
			   "_GLOBAL_OFFSET_TABLE_") == 0)
			/* "Define" it as absolute. */
			symbols[i].st_shndx = SHN_ABS;
		module->arch.syminfo[i].got_offset = -1UL;
		module->arch.syminfo[i].got_initialized = 0;
	}

	/* Allocate GOT entries for symbols that need it. */
	module->arch.got_size = 0;
	for (i = 0; i < hdr->e_shnum; i++) {
		if (sechdrs[i].sh_type != SHT_RELA)
			continue;
		nrela = sechdrs[i].sh_size / sizeof(Elf32_Rela);
		rela = (void *)hdr + sechdrs[i].sh_offset;
		for (j = 0; j < nrela; j++) {
			ret = check_rela(rela + j, module,
					 strings, symbols);
			if (ret)
				goto out_free_syminfo;
		}
	}

	/*
	 * Increase core size to make room for GOT and set start
	 * offset for GOT.
	 */
	module->core_size = ALIGN(module->core_size, 4);
	module->arch.got_offset = module->core_size;
	module->core_size += module->arch.got_size;

	return 0;

out_free_syminfo:
	vfree(module->arch.syminfo);
	module->arch.syminfo = NULL;

	return ret;
}

static inline int reloc_overflow(struct module *module, const char *reloc_name,
				 Elf32_Addr relocation)
{
	printk(KERN_ERR "module %s: Value %lx does not fit relocation %s\n",
	       module->name, (unsigned long)relocation, reloc_name);
	return -ENOEXEC;
}

#define get_u16(loc)		(*((uint16_t *)loc))
#define put_u16(loc, val)	(*((uint16_t *)loc) = (val))

int apply_relocate_add(Elf32_Shdr *sechdrs, const char *strtab,
		       unsigned int symindex, unsigned int relindex,
		       struct module *module)
{
	Elf32_Shdr *symsec = sechdrs + symindex;
	Elf32_Shdr *relsec = sechdrs + relindex;
	Elf32_Shdr *dstsec = sechdrs + relsec->sh_info;
	Elf32_Rela *rel = (void *)relsec->sh_addr;
	unsigned int i;
	int ret = 0;

	for (i = 0; i < relsec->sh_size / sizeof(Elf32_Rela); i++, rel++) {
		struct mod_arch_syminfo *info;
		Elf32_Sym *sym;
		Elf32_Addr relocation;
		uint32_t *location;
		uint32_t value;

		location = (void *)dstsec->sh_addr + rel->r_offset;
		sym = (Elf32_Sym *)symsec->sh_addr + ELF32_R_SYM(rel->r_info);
		relocation = sym->st_value + rel->r_addend;

		info = module->arch.syminfo + ELF32_R_SYM(rel->r_info);

		/* Initialize GOT entry if necessary */
		switch (ELF32_R_TYPE(rel->r_info)) {
		case R_AVR32_GOT32:
		case R_AVR32_GOT16:
		case R_AVR32_GOT8:
		case R_AVR32_GOT21S:
		case R_AVR32_GOT18SW:
		case R_AVR32_GOT16S:
			if (!info->got_initialized) {
				Elf32_Addr *gotent;

				gotent = (module->module_core
					  + module->arch.got_offset
					  + info->got_offset);
				*gotent = relocation;
				info->got_initialized = 1;
			}

			relocation = info->got_offset;
			break;
		}

		switch (ELF32_R_TYPE(rel->r_info)) {
		case R_AVR32_32:
		case R_AVR32_32_CPENT:
			*location = relocation;
			break;
		case R_AVR32_22H_PCREL:
			relocation -= (Elf32_Addr)location;
			if ((relocation & 0xffe00001) != 0
			    && (relocation & 0xffc00001) != 0xffc00000)
				return reloc_overflow(module,
						      "R_AVR32_22H_PCREL",
						      relocation);
			relocation >>= 1;

			value = *location;
			value = ((value & 0xe1ef0000)
				 | (relocation & 0xffff)
				 | ((relocation & 0x10000) << 4)
				 | ((relocation & 0x1e0000) << 8));
			*location = value;
			break;
		case R_AVR32_11H_PCREL:
			relocation -= (Elf32_Addr)location;
			if ((relocation & 0xfffffc01) != 0
			    && (relocation & 0xfffff801) != 0xfffff800)
				return reloc_overflow(module,
						      "R_AVR32_11H_PCREL",
						      relocation);
			value = get_u16(location);
			value = ((value & 0xf00c)
				 | ((relocation & 0x1fe) << 3)
				 | ((relocation & 0x600) >> 9));
			put_u16(location, value);
			break;
		case R_AVR32_9H_PCREL:
			relocation -= (Elf32_Addr)location;
			if ((relocation & 0xffffff01) != 0
			    && (relocation & 0xfffffe01) != 0xfffffe00)
				return reloc_overflow(module,
						      "R_AVR32_9H_PCREL",
						      relocation);
			value = get_u16(location);
			value = ((value & 0xf00f)
				 | ((relocation & 0x1fe) << 3));
			put_u16(location, value);
			break;
		case R_AVR32_9UW_PCREL:
			relocation -= ((Elf32_Addr)location) & 0xfffffffc;
			if ((relocation & 0xfffffc03) != 0)
				return reloc_overflow(module,
						      "R_AVR32_9UW_PCREL",
						      relocation);
			value = get_u16(location);
			value = ((value & 0xf80f)
				 | ((relocation & 0x1fc) << 2));
			put_u16(location, value);
			break;
		case R_AVR32_GOTPC:
			/*
			 * R6 = PC - (PC - GOT)
			 *
			 * At this point, relocation contains the
			 * value of PC.  Just subtract the value of
			 * GOT, and we're done.
			 */
			pr_debug("GOTPC: PC=0x%x, got_offset=0x%lx, core=0x%p\n",
				 relocation, module->arch.got_offset,
				 module->module_core);
			relocation -= ((unsigned long)module->module_core
				       + module->arch.got_offset);
			*location = relocation;
			break;
		case R_AVR32_GOT18SW:
			if ((relocation & 0xfffe0003) != 0
			    && (relocation & 0xfffc0003) != 0xffff0000)
				return reloc_overflow(module, "R_AVR32_GOT18SW",
						     relocation);
			relocation >>= 2;
			/* fall through */
		case R_AVR32_GOT16S:
			if ((relocation & 0xffff8000) != 0
			    && (relocation & 0xffff0000) != 0xffff0000)
				return reloc_overflow(module, "R_AVR32_GOT16S",
						      relocation);
			pr_debug("GOT reloc @ 0x%x -> %u\n",
				 rel->r_offset, relocation);
			value = *location;
			value = ((value & 0xffff0000)
				 | (relocation & 0xffff));
			*location = value;
			break;

		default:
			printk(KERN_ERR "module %s: Unknown relocation: %u\n",
			       module->name, ELF32_R_TYPE(rel->r_info));
			return -ENOEXEC;
		}
	}

	return ret;
}

int apply_relocate(Elf32_Shdr *sechdrs, const char *strtab,
		   unsigned int symindex, unsigned int relindex,
		   struct module *module)
{
	printk(KERN_ERR "module %s: REL relocations are not supported\n",
		module->name);
	return -ENOEXEC;
}

int module_finalize(const Elf_Ehdr *hdr, const Elf_Shdr *sechdrs,
		    struct module *module)
{
	vfree(module->arch.syminfo);
	module->arch.syminfo = NULL;

	return 0;
}

void module_arch_cleanup(struct module *module)
{
}
Commit	Line	Data
5f97f7f9 HS	1	/*
	2	* AVR32-specific kernel module loader
	3	*
	4	* Copyright (C) 2005-2006 Atmel Corporation
	5	*
	6	* GOT initialization parts are based on the s390 version
	7	* Copyright (C) 2002, 2003 IBM Deutschland Entwicklung GmbH,
	8	* IBM Corporation
	9	*
	10	* This program is free software; you can redistribute it and/or modify
	11	* it under the terms of the GNU General Public License version 2 as
	12	* published by the Free Software Foundation.
	13	*/
	14
623b0355	15	#include <linux/bug.h>
5f97f7f9	16	#include <linux/elf.h>
623b0355 HS	17	#include <linux/kernel.h>
	18	#include <linux/module.h>
	19	#include <linux/moduleloader.h>
5f97f7f9 HS	20	#include <linux/vmalloc.h>
	21
	22	void *module_alloc(unsigned long size)
	23	{
	24	if (size == 0)
	25	return NULL;
	26	return vmalloc(size);
	27	}
	28
	29	void module_free(struct module mod, void module_region)
	30	{
	31	vfree(mod->arch.syminfo);
	32	mod->arch.syminfo = NULL;
	33
	34	vfree(module_region);
5f97f7f9 HS	35	}
	36
	37	static inline int check_rela(Elf32_Rela rela, struct module module,
	38	char strings, Elf32_Sym symbols)
	39	{
	40	struct mod_arch_syminfo *info;
	41
	42	info = module->arch.syminfo + ELF32_R_SYM(rela->r_info);
	43	switch (ELF32_R_TYPE(rela->r_info)) {
	44	case R_AVR32_GOT32:
	45	case R_AVR32_GOT16:
	46	case R_AVR32_GOT8:
	47	case R_AVR32_GOT21S:
	48	case R_AVR32_GOT18SW: /* mcall */
	49	case R_AVR32_GOT16S: /* ld.w */
	50	if (rela->r_addend != 0) {
	51	printk(KERN_ERR
	52	"GOT relocation against %s at offset %u with addend\n",
	53	strings + symbols[ELF32_R_SYM(rela->r_info)].st_name,
	54	rela->r_offset);
	55	return -ENOEXEC;
	56	}
	57	if (info->got_offset == -1UL) {
	58	info->got_offset = module->arch.got_size;
	59	module->arch.got_size += sizeof(void *);
	60	}
	61	pr_debug("GOT[%3lu] %s\n", info->got_offset,
	62	strings + symbols[ELF32_R_SYM(rela->r_info)].st_name);
	63	break;
	64	}
	65
	66	return 0;
	67	}
	68
	69	int module_frob_arch_sections(Elf_Ehdr hdr, Elf_Shdr sechdrs,
	70	char secstrings, struct module module)
	71	{
	72	Elf32_Shdr *symtab;
	73	Elf32_Sym *symbols;
	74	Elf32_Rela *rela;
	75	char *strings;
	76	int nrela, i, j;
	77	int ret;
	78
	79	/* Find the symbol table */
	80	symtab = NULL;
	81	for (i = 0; i < hdr->e_shnum; i++)
	82	switch (sechdrs[i].sh_type) {
	83	case SHT_SYMTAB:
	84	symtab = &sechdrs[i];
	85	break;
	86	}
	87	if (!symtab) {
	88	printk(KERN_ERR "module %s: no symbol table\n", module->name);
	89	return -ENOEXEC;
	90	}
	91
	92	/* Allocate room for one syminfo structure per symbol. */
	93	module->arch.nsyms = symtab->sh_size / sizeof(Elf_Sym);
	94	module->arch.syminfo = vmalloc(module->arch.nsyms
	95	* sizeof(struct mod_arch_syminfo));
	96	if (!module->arch.syminfo)
	97	return -ENOMEM;
	98
99	symbols = (void *)hdr + symtab->sh_offset;
100	strings = (void *)hdr + sechdrs[symtab->sh_link].sh_offset;
101	for (i = 0; i < module->arch.nsyms; i++) {
102	if (symbols[i].st_shndx == SHN_UNDEF &&
103	strcmp(strings + symbols[i].st_name,
104	"_GLOBAL_OFFSET_TABLE_") == 0)
105	/* "Define" it as absolute. */
106	symbols[i].st_shndx = SHN_ABS;
107	module->arch.syminfo[i].got_offset = -1UL;
108	module->arch.syminfo[i].got_initialized = 0;
109	}
110
111	/* Allocate GOT entries for symbols that need it. */
112	module->arch.got_size = 0;
113	for (i = 0; i < hdr->e_shnum; i++) {
114	if (sechdrs[i].sh_type != SHT_RELA)
115	continue;
116	nrela = sechdrs[i].sh_size / sizeof(Elf32_Rela);
117	rela = (void *)hdr + sechdrs[i].sh_offset;
118	for (j = 0; j < nrela; j++) {
119	ret = check_rela(rela + j, module,
120	strings, symbols);
121	if (ret)
122	goto out_free_syminfo;
123	}
124	}
125
126	/*
127	* Increase core size to make room for GOT and set start
128	* offset for GOT.
129	*/
130	module->core_size = ALIGN(module->core_size, 4);
131	module->arch.got_offset = module->core_size;
132	module->core_size += module->arch.got_size;
133
134	return 0;
135
136	out_free_syminfo:
137	vfree(module->arch.syminfo);
138	module->arch.syminfo = NULL;
139
140	return ret;
141	}
142
143	static inline int reloc_overflow(struct module module, const char reloc_name,
144	Elf32_Addr relocation)
145	{
146	printk(KERN_ERR "module %s: Value %lx does not fit relocation %s\n",
147	module->name, (unsigned long)relocation, reloc_name);
148	return -ENOEXEC;
149	}
150
151	#define get_u16(loc) (((uint16_t )loc))
152	#define put_u16(loc, val) (((uint16_t )loc) = (val))
153
154	int apply_relocate_add(Elf32_Shdr sechdrs, const char strtab,
155	unsigned int symindex, unsigned int relindex,
156	struct module *module)
157	{
158	Elf32_Shdr *symsec = sechdrs + symindex;
159	Elf32_Shdr *relsec = sechdrs + relindex;
160	Elf32_Shdr *dstsec = sechdrs + relsec->sh_info;
161	Elf32_Rela rel = (void )relsec->sh_addr;
162	unsigned int i;
163	int ret = 0;
164
165	for (i = 0; i < relsec->sh_size / sizeof(Elf32_Rela); i++, rel++) {
166	struct mod_arch_syminfo *info;
167	Elf32_Sym *sym;
168	Elf32_Addr relocation;
169	uint32_t *location;
170	uint32_t value;
171
172	location = (void *)dstsec->sh_addr + rel->r_offset;
173	sym = (Elf32_Sym *)symsec->sh_addr + ELF32_R_SYM(rel->r_info);
174	relocation = sym->st_value + rel->r_addend;
175
176	info = module->arch.syminfo + ELF32_R_SYM(rel->r_info);
177
178	/* Initialize GOT entry if necessary */
179	switch (ELF32_R_TYPE(rel->r_info)) {
180	case R_AVR32_GOT32:
181	case R_AVR32_GOT16:
182	case R_AVR32_GOT8:
183	case R_AVR32_GOT21S:
184	case R_AVR32_GOT18SW:
185	case R_AVR32_GOT16S:
186	if (!info->got_initialized) {
187	Elf32_Addr *gotent;
188
189	gotent = (module->module_core
190	+ module->arch.got_offset
191	+ info->got_offset);
192	*gotent = relocation;
193	info->got_initialized = 1;
194	}
195
196	relocation = info->got_offset;
197	break;
198	}
199
200	switch (ELF32_R_TYPE(rel->r_info)) {
201	case R_AVR32_32:
202	case R_AVR32_32_CPENT:
203	*location = relocation;
204	break;
205	case R_AVR32_22H_PCREL:
206	relocation -= (Elf32_Addr)location;
207	if ((relocation & 0xffe00001) != 0
208	&& (relocation & 0xffc00001) != 0xffc00000)
209	return reloc_overflow(module,
210	"R_AVR32_22H_PCREL",
211	relocation);
212	relocation >>= 1;
213
214	value = *location;
215	value = ((value & 0xe1ef0000)
216	\| (relocation & 0xffff)
217	\| ((relocation & 0x10000) << 4)
218	\| ((relocation & 0x1e0000) << 8));
219	*location = value;
220	break;
221	case R_AVR32_11H_PCREL:
222	relocation -= (Elf32_Addr)location;
223	if ((relocation & 0xfffffc01) != 0
224	&& (relocation & 0xfffff801) != 0xfffff800)
225	return reloc_overflow(module,
226	"R_AVR32_11H_PCREL",
227	relocation);
228	value = get_u16(location);
229	value = ((value & 0xf00c)
230	\| ((relocation & 0x1fe) << 3)
231	\| ((relocation & 0x600) >> 9));
232	put_u16(location, value);
233	break;
234	case R_AVR32_9H_PCREL:
235	relocation -= (Elf32_Addr)location;
236	if ((relocation & 0xffffff01) != 0
237	&& (relocation & 0xfffffe01) != 0xfffffe00)
238	return reloc_overflow(module,
239	"R_AVR32_9H_PCREL",
240	relocation);
241	value = get_u16(location);
242	value = ((value & 0xf00f)
243	\| ((relocation & 0x1fe) << 3));
244	put_u16(location, value);
245	break;
246	case R_AVR32_9UW_PCREL:
247	relocation -= ((Elf32_Addr)location) & 0xfffffffc;
248	if ((relocation & 0xfffffc03) != 0)
249	return reloc_overflow(module,
250	"R_AVR32_9UW_PCREL",
251	relocation);
252	value = get_u16(location);
253	value = ((value & 0xf80f)
254	\| ((relocation & 0x1fc) << 2));
255	put_u16(location, value);
256	break;
257	case R_AVR32_GOTPC:
258	/*
259	* R6 = PC - (PC - GOT)
260	*
261	* At this point, relocation contains the
262	* value of PC. Just subtract the value of
263	* GOT, and we're done.
264	*/
6ea850b5	265	pr_debug("GOTPC: PC=0x%x, got_offset=0x%lx, core=0x%p\n",
5f97f7f9 HS	266	relocation, module->arch.got_offset,
	267	module->module_core);
	268	relocation -= ((unsigned long)module->module_core
	269	+ module->arch.got_offset);
	270	*location = relocation;
	271	break;
	272	case R_AVR32_GOT18SW:
	273	if ((relocation & 0xfffe0003) != 0
	274	&& (relocation & 0xfffc0003) != 0xffff0000)
	275	return reloc_overflow(module, "R_AVR32_GOT18SW",
	276	relocation);
	277	relocation >>= 2;
	278	/* fall through */
	279	case R_AVR32_GOT16S:
	280	if ((relocation & 0xffff8000) != 0
	281	&& (relocation & 0xffff0000) != 0xffff0000)
	282	return reloc_overflow(module, "R_AVR32_GOT16S",
	283	relocation);
6ea850b5	284	pr_debug("GOT reloc @ 0x%x -> %u\n",
5f97f7f9 HS	285	rel->r_offset, relocation);
	286	value = *location;
	287	value = ((value & 0xffff0000)
	288	\| (relocation & 0xffff));
	289	*location = value;
	290	break;
	291
	292	default:
	293	printk(KERN_ERR "module %s: Unknown relocation: %u\n",
	294	module->name, ELF32_R_TYPE(rel->r_info));
	295	return -ENOEXEC;
	296	}
	297	}
	298
	299	return ret;
	300	}
	301
	302	int apply_relocate(Elf32_Shdr sechdrs, const char strtab,
	303	unsigned int symindex, unsigned int relindex,
	304	struct module *module)
	305	{
	306	printk(KERN_ERR "module %s: REL relocations are not supported\n",
	307	module->name);
	308	return -ENOEXEC;
	309	}
	310
	311	int module_finalize(const Elf_Ehdr hdr, const Elf_Shdr sechdrs,
	312	struct module *module)
	313	{
	314	vfree(module->arch.syminfo);
	315	module->arch.syminfo = NULL;
	316
5336377d	317	return 0;
5f97f7f9 HS	318	}
	319
	320	void module_arch_cleanup(struct module *module)
	321	{
5f97f7f9	322	}