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