1
2
3
4
5
6
7
8
9
10
11
12
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
22void *module_alloc(unsigned long size)
23{
24 if (size == 0)
25 return NULL;
26 return vmalloc(size);
27}
28
29void 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
37static 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:
49 case R_AVR32_GOT16S:
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
69int 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
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
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
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
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
128
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
136out_free_syminfo:
137 vfree(module->arch.syminfo);
138 module->arch.syminfo = NULL;
139
140 return ret;
141}
142
143static 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
154int 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
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
260
261
262
263
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
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
302int 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
311int 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
320void module_arch_cleanup(struct module *module)
321{
322 module_bug_cleanup(module);
323}
324
