Merge git://git.kernel.org/pub/scm/linux/kernel/git/davem/sparc-2.6
[linux-2.6.git] / arch / avr32 / kernel / module.c
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
15 #include <linux/bug.h>
16 #include <linux/elf.h>
17 #include <linux/kernel.h>
18 #include <linux/module.h>
19 #include <linux/moduleloader.h>
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);
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                          */
265                         pr_debug("GOTPC: PC=0x%x, got_offset=0x%lx, core=0x%p\n",
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);
284                         pr_debug("GOT reloc @ 0x%x -> %u\n",
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
317         return module_bug_finalize(hdr, sechdrs, module);
318 }
319
320 void module_arch_cleanup(struct module *module)
321 {
322         module_bug_cleanup(module);
323 }