1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21#undef DEBUG
22
23#include <linux/moduleloader.h>
24#include <linux/elf.h>
25#include <linux/mm.h>
26#include <linux/vmalloc.h>
27#include <linux/slab.h>
28#include <linux/fs.h>
29#include <linux/string.h>
30#include <linux/kernel.h>
31#include <linux/module.h>
32#include <linux/spinlock.h>
33#include <asm/pgtable.h>
34
35struct mips_hi16 {
36 struct mips_hi16 *next;
37 Elf_Addr *addr;
38 Elf_Addr value;
39};
40
41static struct mips_hi16 *mips_hi16_list;
42
43static LIST_HEAD(dbe_list);
44static DEFINE_SPINLOCK(dbe_lock);
45
46void *module_alloc(unsigned long size)
47{
48#ifdef MODULE_START
49 struct vm_struct *area;
50
51 size = PAGE_ALIGN(size);
52 if (!size)
53 return NULL;
54
55 area = __get_vm_area(size, VM_ALLOC, MODULE_START, MODULE_END);
56 if (!area)
57 return NULL;
58
59 return __vmalloc_area(area, GFP_KERNEL, PAGE_KERNEL);
60#else
61 if (size == 0)
62 return NULL;
63 return vmalloc(size);
64#endif
65}
66
67
68void module_free(struct module *mod, void *module_region)
69{
70 vfree(module_region);
71}
72
73int module_frob_arch_sections(Elf_Ehdr *hdr, Elf_Shdr *sechdrs,
74 char *secstrings, struct module *mod)
75{
76 return 0;
77}
78
79static int apply_r_mips_none(struct module *me, u32 *location, Elf_Addr v)
80{
81 return 0;
82}
83
84static int apply_r_mips_32_rel(struct module *me, u32 *location, Elf_Addr v)
85{
86 *location += v;
87
88 return 0;
89}
90
91static int apply_r_mips_32_rela(struct module *me, u32 *location, Elf_Addr v)
92{
93 *location = v;
94
95 return 0;
96}
97
98static int apply_r_mips_26_rel(struct module *me, u32 *location, Elf_Addr v)
99{
100 if (v % 4) {
101 pr_err("module %s: dangerous R_MIPS_26 REL relocation\n",
102 me->name);
103 return -ENOEXEC;
104 }
105
106 if ((v & 0xf0000000) != (((unsigned long)location + 4) & 0xf0000000)) {
107 printk(KERN_ERR
108 "module %s: relocation overflow\n",
109 me->name);
110 return -ENOEXEC;
111 }
112
113 *location = (*location & ~0x03ffffff) |
114 ((*location + (v >> 2)) & 0x03ffffff);
115
116 return 0;
117}
118
119static int apply_r_mips_26_rela(struct module *me, u32 *location, Elf_Addr v)
120{
121 if (v % 4) {
122 pr_err("module %s: dangerous R_MIPS_26 RELArelocation\n",
123 me->name);
124 return -ENOEXEC;
125 }
126
127 if ((v & 0xf0000000) != (((unsigned long)location + 4) & 0xf0000000)) {
128 printk(KERN_ERR
129 "module %s: relocation overflow\n",
130 me->name);
131 return -ENOEXEC;
132 }
133
134 *location = (*location & ~0x03ffffff) | ((v >> 2) & 0x03ffffff);
135
136 return 0;
137}
138
139static int apply_r_mips_hi16_rel(struct module *me, u32 *location, Elf_Addr v)
140{
141 struct mips_hi16 *n;
142
143
144
145
146
147
148 n = kmalloc(sizeof *n, GFP_KERNEL);
149 if (!n)
150 return -ENOMEM;
151
152 n->addr = (Elf_Addr *)location;
153 n->value = v;
154 n->next = mips_hi16_list;
155 mips_hi16_list = n;
156
157 return 0;
158}
159
160static int apply_r_mips_hi16_rela(struct module *me, u32 *location, Elf_Addr v)
161{
162 *location = (*location & 0xffff0000) |
163 ((((long long) v + 0x8000LL) >> 16) & 0xffff);
164
165 return 0;
166}
167
168static int apply_r_mips_lo16_rel(struct module *me, u32 *location, Elf_Addr v)
169{
170 unsigned long insnlo = *location;
171 Elf_Addr val, vallo;
172
173
174 vallo = ((insnlo & 0xffff) ^ 0x8000) - 0x8000;
175
176 if (mips_hi16_list != NULL) {
177 struct mips_hi16 *l;
178
179 l = mips_hi16_list;
180 while (l != NULL) {
181 struct mips_hi16 *next;
182 unsigned long insn;
183
184
185
186
187 if (v != l->value)
188 goto out_danger;
189
190
191
192
193
194
195
196 insn = *l->addr;
197 val = ((insn & 0xffff) << 16) + vallo;
198 val += v;
199
200
201
202
203
204 val = ((val >> 16) + ((val & 0x8000) != 0)) & 0xffff;
205
206 insn = (insn & ~0xffff) | val;
207 *l->addr = insn;
208
209 next = l->next;
210 kfree(l);
211 l = next;
212 }
213
214 mips_hi16_list = NULL;
215 }
216
217
218
219
220 val = v + vallo;
221 insnlo = (insnlo & ~0xffff) | (val & 0xffff);
222 *location = insnlo;
223
224 return 0;
225
226out_danger:
227 pr_err("module %s: dangerous R_MIPS_LO16 REL relocation\n", me->name);
228
229 return -ENOEXEC;
230}
231
232static int apply_r_mips_lo16_rela(struct module *me, u32 *location, Elf_Addr v)
233{
234 *location = (*location & 0xffff0000) | (v & 0xffff);
235
236 return 0;
237}
238
239static int apply_r_mips_64_rela(struct module *me, u32 *location, Elf_Addr v)
240{
241 *(Elf_Addr *)location = v;
242
243 return 0;
244}
245
246static int apply_r_mips_higher_rela(struct module *me, u32 *location,
247 Elf_Addr v)
248{
249 *location = (*location & 0xffff0000) |
250 ((((long long) v + 0x80008000LL) >> 32) & 0xffff);
251
252 return 0;
253}
254
255static int apply_r_mips_highest_rela(struct module *me, u32 *location,
256 Elf_Addr v)
257{
258 *location = (*location & 0xffff0000) |
259 ((((long long) v + 0x800080008000LL) >> 48) & 0xffff);
260
261 return 0;
262}
263
264static int (*reloc_handlers_rel[]) (struct module *me, u32 *location,
265 Elf_Addr v) = {
266 [R_MIPS_NONE] = apply_r_mips_none,
267 [R_MIPS_32] = apply_r_mips_32_rel,
268 [R_MIPS_26] = apply_r_mips_26_rel,
269 [R_MIPS_HI16] = apply_r_mips_hi16_rel,
270 [R_MIPS_LO16] = apply_r_mips_lo16_rel
271};
272
273static int (*reloc_handlers_rela[]) (struct module *me, u32 *location,
274 Elf_Addr v) = {
275 [R_MIPS_NONE] = apply_r_mips_none,
276 [R_MIPS_32] = apply_r_mips_32_rela,
277 [R_MIPS_26] = apply_r_mips_26_rela,
278 [R_MIPS_HI16] = apply_r_mips_hi16_rela,
279 [R_MIPS_LO16] = apply_r_mips_lo16_rela,
280 [R_MIPS_64] = apply_r_mips_64_rela,
281 [R_MIPS_HIGHER] = apply_r_mips_higher_rela,
282 [R_MIPS_HIGHEST] = apply_r_mips_highest_rela
283};
284
285int apply_relocate(Elf_Shdr *sechdrs, const char *strtab,
286 unsigned int symindex, unsigned int relsec,
287 struct module *me)
288{
289 Elf_Mips_Rel *rel = (void *) sechdrs[relsec].sh_addr;
290 Elf_Sym *sym;
291 u32 *location;
292 unsigned int i;
293 Elf_Addr v;
294 int res;
295
296 pr_debug("Applying relocate section %u to %u\n", relsec,
297 sechdrs[relsec].sh_info);
298
299 for (i = 0; i < sechdrs[relsec].sh_size / sizeof(*rel); i++) {
300
301 location = (void *)sechdrs[sechdrs[relsec].sh_info].sh_addr
302 + rel[i].r_offset;
303
304 sym = (Elf_Sym *)sechdrs[symindex].sh_addr
305 + ELF_MIPS_R_SYM(rel[i]);
306 if (IS_ERR_VALUE(sym->st_value)) {
307
308 if (ELF_ST_BIND(sym->st_info) == STB_WEAK)
309 continue;
310 printk(KERN_WARNING "%s: Unknown symbol %s\n",
311 me->name, strtab + sym->st_name);
312 return -ENOENT;
313 }
314
315 v = sym->st_value;
316
317 res = reloc_handlers_rel[ELF_MIPS_R_TYPE(rel[i])](me, location, v);
318 if (res)
319 return res;
320 }
321
322 return 0;
323}
324
325int apply_relocate_add(Elf_Shdr *sechdrs, const char *strtab,
326 unsigned int symindex, unsigned int relsec,
327 struct module *me)
328{
329 Elf_Mips_Rela *rel = (void *) sechdrs[relsec].sh_addr;
330 Elf_Sym *sym;
331 u32 *location;
332 unsigned int i;
333 Elf_Addr v;
334 int res;
335
336 pr_debug("Applying relocate section %u to %u\n", relsec,
337 sechdrs[relsec].sh_info);
338
339 for (i = 0; i < sechdrs[relsec].sh_size / sizeof(*rel); i++) {
340
341 location = (void *)sechdrs[sechdrs[relsec].sh_info].sh_addr
342 + rel[i].r_offset;
343
344 sym = (Elf_Sym *)sechdrs[symindex].sh_addr
345 + ELF_MIPS_R_SYM(rel[i]);
346 if (IS_ERR_VALUE(sym->st_value)) {
347
348 if (ELF_ST_BIND(sym->st_info) == STB_WEAK)
349 continue;
350 printk(KERN_WARNING "%s: Unknown symbol %s\n",
351 me->name, strtab + sym->st_name);
352 return -ENOENT;
353 }
354
355 v = sym->st_value + rel[i].r_addend;
356
357 res = reloc_handlers_rela[ELF_MIPS_R_TYPE(rel[i])](me, location, v);
358 if (res)
359 return res;
360 }
361
362 return 0;
363}
364
365
366const struct exception_table_entry *search_module_dbetables(unsigned long addr)
367{
368 unsigned long flags;
369 const struct exception_table_entry *e = NULL;
370 struct mod_arch_specific *dbe;
371
372 spin_lock_irqsave(&dbe_lock, flags);
373 list_for_each_entry(dbe, &dbe_list, dbe_list) {
374 e = search_extable(dbe->dbe_start, dbe->dbe_end - 1, addr);
375 if (e)
376 break;
377 }
378 spin_unlock_irqrestore(&dbe_lock, flags);
379
380
381
382 return e;
383}
384
385
386int module_finalize(const Elf_Ehdr *hdr,
387 const Elf_Shdr *sechdrs,
388 struct module *me)
389{
390 const Elf_Shdr *s;
391 char *secstrings = (void *)hdr + sechdrs[hdr->e_shstrndx].sh_offset;
392
393 INIT_LIST_HEAD(&me->arch.dbe_list);
394 for (s = sechdrs; s < sechdrs + hdr->e_shnum; s++) {
395 if (strcmp("__dbe_table", secstrings + s->sh_name) != 0)
396 continue;
397 me->arch.dbe_start = (void *)s->sh_addr;
398 me->arch.dbe_end = (void *)s->sh_addr + s->sh_size;
399 spin_lock_irq(&dbe_lock);
400 list_add(&me->arch.dbe_list, &dbe_list);
401 spin_unlock_irq(&dbe_lock);
402 }
403 return 0;
404}
405
406void module_arch_cleanup(struct module *mod)
407{
408 spin_lock_irq(&dbe_lock);
409 list_del(&mod->arch.dbe_list);
410 spin_unlock_irq(&dbe_lock);
411}
412
