1 | /* |
2 | * This file is subject to the terms and conditions of the GNU General Public |
3 | * License. See the file "COPYING" in the main directory of this archive |
4 | * for more details. |
5 | * |
6 | * Copyright (C) 2004, 2005 MIPS Technologies, Inc. All rights reserved. |
7 | * Copyright (C) 2013 Imagination Technologies Ltd. |
8 | * |
9 | * VPE spport module for loading a MIPS SP program into VPE1. The SP |
10 | * environment is rather simple since there are no TLBs. It needs |
11 | * to be relocatable (or partiall linked). Initialize your stack in |
12 | * the startup-code. The loader looks for the symbol __start and sets |
13 | * up the execution to resume from there. To load and run, simply do |
14 | * a cat SP 'binary' to the /dev/vpe1 device. |
15 | */ |
16 | #include <linux/kernel.h> |
17 | #include <linux/device.h> |
18 | #include <linux/fs.h> |
19 | #include <linux/init.h> |
20 | #include <linux/slab.h> |
21 | #include <linux/list.h> |
22 | #include <linux/vmalloc.h> |
23 | #include <linux/elf.h> |
24 | #include <linux/seq_file.h> |
25 | #include <linux/syscalls.h> |
26 | #include <linux/moduleloader.h> |
27 | #include <linux/interrupt.h> |
28 | #include <linux/poll.h> |
29 | #include <linux/memblock.h> |
30 | #include <asm/mipsregs.h> |
31 | #include <asm/mipsmtregs.h> |
32 | #include <asm/cacheflush.h> |
33 | #include <linux/atomic.h> |
34 | #include <asm/mips_mt.h> |
35 | #include <asm/processor.h> |
36 | #include <asm/vpe.h> |
37 | |
38 | #ifndef ARCH_SHF_SMALL |
39 | #define ARCH_SHF_SMALL 0 |
40 | #endif |
41 | |
42 | /* If this is set, the section belongs in the init part of the module */ |
43 | #define INIT_OFFSET_MASK (1UL << (BITS_PER_LONG-1)) |
44 | |
45 | struct vpe_control vpecontrol = { |
46 | .vpe_list_lock = __SPIN_LOCK_UNLOCKED(vpe_list_lock), |
47 | .vpe_list = LIST_HEAD_INIT(vpecontrol.vpe_list), |
48 | .tc_list_lock = __SPIN_LOCK_UNLOCKED(tc_list_lock), |
49 | .tc_list = LIST_HEAD_INIT(vpecontrol.tc_list) |
50 | }; |
51 | |
52 | /* get the vpe associated with this minor */ |
53 | struct vpe *get_vpe(int minor) |
54 | { |
55 | struct vpe *res, *v; |
56 | |
57 | if (!cpu_has_mipsmt) |
58 | return NULL; |
59 | |
60 | res = NULL; |
61 | spin_lock(lock: &vpecontrol.vpe_list_lock); |
62 | list_for_each_entry(v, &vpecontrol.vpe_list, list) { |
63 | if (v->minor == VPE_MODULE_MINOR) { |
64 | res = v; |
65 | break; |
66 | } |
67 | } |
68 | spin_unlock(lock: &vpecontrol.vpe_list_lock); |
69 | |
70 | return res; |
71 | } |
72 | |
73 | /* get the vpe associated with this minor */ |
74 | struct tc *get_tc(int index) |
75 | { |
76 | struct tc *res, *t; |
77 | |
78 | res = NULL; |
79 | spin_lock(lock: &vpecontrol.tc_list_lock); |
80 | list_for_each_entry(t, &vpecontrol.tc_list, list) { |
81 | if (t->index == index) { |
82 | res = t; |
83 | break; |
84 | } |
85 | } |
86 | spin_unlock(lock: &vpecontrol.tc_list_lock); |
87 | |
88 | return res; |
89 | } |
90 | |
91 | /* allocate a vpe and associate it with this minor (or index) */ |
92 | struct vpe *alloc_vpe(int minor) |
93 | { |
94 | struct vpe *v; |
95 | |
96 | v = kzalloc(sizeof(struct vpe), GFP_KERNEL); |
97 | if (v == NULL) |
98 | goto out; |
99 | |
100 | INIT_LIST_HEAD(list: &v->tc); |
101 | spin_lock(lock: &vpecontrol.vpe_list_lock); |
102 | list_add_tail(new: &v->list, head: &vpecontrol.vpe_list); |
103 | spin_unlock(lock: &vpecontrol.vpe_list_lock); |
104 | |
105 | INIT_LIST_HEAD(list: &v->notify); |
106 | v->minor = VPE_MODULE_MINOR; |
107 | |
108 | out: |
109 | return v; |
110 | } |
111 | |
112 | /* allocate a tc. At startup only tc0 is running, all other can be halted. */ |
113 | struct tc *alloc_tc(int index) |
114 | { |
115 | struct tc *tc; |
116 | |
117 | tc = kzalloc(sizeof(struct tc), GFP_KERNEL); |
118 | if (tc == NULL) |
119 | goto out; |
120 | |
121 | INIT_LIST_HEAD(list: &tc->tc); |
122 | tc->index = index; |
123 | |
124 | spin_lock(lock: &vpecontrol.tc_list_lock); |
125 | list_add_tail(new: &tc->list, head: &vpecontrol.tc_list); |
126 | spin_unlock(lock: &vpecontrol.tc_list_lock); |
127 | |
128 | out: |
129 | return tc; |
130 | } |
131 | |
132 | /* clean up and free everything */ |
133 | void release_vpe(struct vpe *v) |
134 | { |
135 | list_del(entry: &v->list); |
136 | if (v->load_addr) |
137 | release_progmem(v->load_addr); |
138 | kfree(objp: v); |
139 | } |
140 | |
141 | /* Find some VPE program space */ |
142 | void *alloc_progmem(unsigned long len) |
143 | { |
144 | void *addr; |
145 | |
146 | #ifdef CONFIG_MIPS_VPE_LOADER_TOM |
147 | /* |
148 | * This means you must tell Linux to use less memory than you |
149 | * physically have, for example by passing a mem= boot argument. |
150 | */ |
151 | addr = pfn_to_kaddr(max_low_pfn); |
152 | memset(addr, 0, len); |
153 | #else |
154 | /* simple grab some mem for now */ |
155 | addr = kzalloc(size: len, GFP_KERNEL); |
156 | #endif |
157 | |
158 | return addr; |
159 | } |
160 | |
161 | void release_progmem(void *ptr) |
162 | { |
163 | #ifndef CONFIG_MIPS_VPE_LOADER_TOM |
164 | kfree(objp: ptr); |
165 | #endif |
166 | } |
167 | |
168 | /* Update size with this section: return offset. */ |
169 | static long get_offset(unsigned long *size, Elf_Shdr *sechdr) |
170 | { |
171 | long ret; |
172 | |
173 | ret = ALIGN(*size, sechdr->sh_addralign ? : 1); |
174 | *size = ret + sechdr->sh_size; |
175 | return ret; |
176 | } |
177 | |
178 | /* Lay out the SHF_ALLOC sections in a way not dissimilar to how ld |
179 | might -- code, read-only data, read-write data, small data. Tally |
180 | sizes, and place the offsets into sh_entsize fields: high bit means it |
181 | belongs in init. */ |
182 | static void layout_sections(struct module *mod, const Elf_Ehdr *hdr, |
183 | Elf_Shdr *sechdrs, const char *secstrings) |
184 | { |
185 | static unsigned long const masks[][2] = { |
186 | /* NOTE: all executable code must be the first section |
187 | * in this array; otherwise modify the text_size |
188 | * finder in the two loops below */ |
189 | {SHF_EXECINSTR | SHF_ALLOC, ARCH_SHF_SMALL}, |
190 | {SHF_ALLOC, SHF_WRITE | ARCH_SHF_SMALL}, |
191 | {SHF_WRITE | SHF_ALLOC, ARCH_SHF_SMALL}, |
192 | {ARCH_SHF_SMALL | SHF_ALLOC, 0} |
193 | }; |
194 | unsigned int m, i; |
195 | |
196 | for (i = 0; i < hdr->e_shnum; i++) |
197 | sechdrs[i].sh_entsize = ~0UL; |
198 | |
199 | for (m = 0; m < ARRAY_SIZE(masks); ++m) { |
200 | for (i = 0; i < hdr->e_shnum; ++i) { |
201 | Elf_Shdr *s = &sechdrs[i]; |
202 | struct module_memory *mod_mem; |
203 | |
204 | mod_mem = &mod->mem[MOD_TEXT]; |
205 | |
206 | if ((s->sh_flags & masks[m][0]) != masks[m][0] |
207 | || (s->sh_flags & masks[m][1]) |
208 | || s->sh_entsize != ~0UL) |
209 | continue; |
210 | s->sh_entsize = |
211 | get_offset(size: (unsigned long *)&mod_mem->size, sechdr: s); |
212 | } |
213 | } |
214 | } |
215 | |
216 | /* from module-elf32.c, but subverted a little */ |
217 | |
218 | struct mips_hi16 { |
219 | struct mips_hi16 *next; |
220 | Elf32_Addr *addr; |
221 | Elf32_Addr value; |
222 | }; |
223 | |
224 | static struct mips_hi16 *mips_hi16_list; |
225 | static unsigned int gp_offs, gp_addr; |
226 | |
227 | static int apply_r_mips_none(struct module *me, uint32_t *location, |
228 | Elf32_Addr v) |
229 | { |
230 | return 0; |
231 | } |
232 | |
233 | static int apply_r_mips_gprel16(struct module *me, uint32_t *location, |
234 | Elf32_Addr v) |
235 | { |
236 | int rel; |
237 | |
238 | if (!(*location & 0xffff)) { |
239 | rel = (int)v - gp_addr; |
240 | } else { |
241 | /* .sbss + gp(relative) + offset */ |
242 | /* kludge! */ |
243 | rel = (int)(short)((int)v + gp_offs + |
244 | (int)(short)(*location & 0xffff) - gp_addr); |
245 | } |
246 | |
247 | if ((rel > 32768) || (rel < -32768)) { |
248 | pr_debug("VPE loader: apply_r_mips_gprel16: relative address 0x%x out of range of gp register\n" , |
249 | rel); |
250 | return -ENOEXEC; |
251 | } |
252 | |
253 | *location = (*location & 0xffff0000) | (rel & 0xffff); |
254 | |
255 | return 0; |
256 | } |
257 | |
258 | static int apply_r_mips_pc16(struct module *me, uint32_t *location, |
259 | Elf32_Addr v) |
260 | { |
261 | int rel; |
262 | rel = (((unsigned int)v - (unsigned int)location)); |
263 | rel >>= 2; /* because the offset is in _instructions_ not bytes. */ |
264 | rel -= 1; /* and one instruction less due to the branch delay slot. */ |
265 | |
266 | if ((rel > 32768) || (rel < -32768)) { |
267 | pr_debug("VPE loader: apply_r_mips_pc16: relative address out of range 0x%x\n" , |
268 | rel); |
269 | return -ENOEXEC; |
270 | } |
271 | |
272 | *location = (*location & 0xffff0000) | (rel & 0xffff); |
273 | |
274 | return 0; |
275 | } |
276 | |
277 | static int apply_r_mips_32(struct module *me, uint32_t *location, |
278 | Elf32_Addr v) |
279 | { |
280 | *location += v; |
281 | |
282 | return 0; |
283 | } |
284 | |
285 | static int apply_r_mips_26(struct module *me, uint32_t *location, |
286 | Elf32_Addr v) |
287 | { |
288 | if (v % 4) { |
289 | pr_debug("VPE loader: apply_r_mips_26: unaligned relocation\n" ); |
290 | return -ENOEXEC; |
291 | } |
292 | |
293 | /* |
294 | * Not desperately convinced this is a good check of an overflow condition |
295 | * anyway. But it gets in the way of handling undefined weak symbols which |
296 | * we want to set to zero. |
297 | * if ((v & 0xf0000000) != (((unsigned long)location + 4) & 0xf0000000)) { |
298 | * printk(KERN_ERR |
299 | * "module %s: relocation overflow\n", |
300 | * me->name); |
301 | * return -ENOEXEC; |
302 | * } |
303 | */ |
304 | |
305 | *location = (*location & ~0x03ffffff) | |
306 | ((*location + (v >> 2)) & 0x03ffffff); |
307 | return 0; |
308 | } |
309 | |
310 | static int apply_r_mips_hi16(struct module *me, uint32_t *location, |
311 | Elf32_Addr v) |
312 | { |
313 | struct mips_hi16 *n; |
314 | |
315 | /* |
316 | * We cannot relocate this one now because we don't know the value of |
317 | * the carry we need to add. Save the information, and let LO16 do the |
318 | * actual relocation. |
319 | */ |
320 | n = kmalloc(size: sizeof(*n), GFP_KERNEL); |
321 | if (!n) |
322 | return -ENOMEM; |
323 | |
324 | n->addr = location; |
325 | n->value = v; |
326 | n->next = mips_hi16_list; |
327 | mips_hi16_list = n; |
328 | |
329 | return 0; |
330 | } |
331 | |
332 | static int apply_r_mips_lo16(struct module *me, uint32_t *location, |
333 | Elf32_Addr v) |
334 | { |
335 | unsigned long insnlo = *location; |
336 | Elf32_Addr val, vallo; |
337 | struct mips_hi16 *l, *next; |
338 | |
339 | /* Sign extend the addend we extract from the lo insn. */ |
340 | vallo = ((insnlo & 0xffff) ^ 0x8000) - 0x8000; |
341 | |
342 | if (mips_hi16_list != NULL) { |
343 | |
344 | l = mips_hi16_list; |
345 | while (l != NULL) { |
346 | unsigned long insn; |
347 | |
348 | /* |
349 | * The value for the HI16 had best be the same. |
350 | */ |
351 | if (v != l->value) { |
352 | pr_debug("VPE loader: apply_r_mips_lo16/hi16: inconsistent value information\n" ); |
353 | goto out_free; |
354 | } |
355 | |
356 | /* |
357 | * Do the HI16 relocation. Note that we actually don't |
358 | * need to know anything about the LO16 itself, except |
359 | * where to find the low 16 bits of the addend needed |
360 | * by the LO16. |
361 | */ |
362 | insn = *l->addr; |
363 | val = ((insn & 0xffff) << 16) + vallo; |
364 | val += v; |
365 | |
366 | /* |
367 | * Account for the sign extension that will happen in |
368 | * the low bits. |
369 | */ |
370 | val = ((val >> 16) + ((val & 0x8000) != 0)) & 0xffff; |
371 | |
372 | insn = (insn & ~0xffff) | val; |
373 | *l->addr = insn; |
374 | |
375 | next = l->next; |
376 | kfree(objp: l); |
377 | l = next; |
378 | } |
379 | |
380 | mips_hi16_list = NULL; |
381 | } |
382 | |
383 | /* |
384 | * Ok, we're done with the HI16 relocs. Now deal with the LO16. |
385 | */ |
386 | val = v + vallo; |
387 | insnlo = (insnlo & ~0xffff) | (val & 0xffff); |
388 | *location = insnlo; |
389 | |
390 | return 0; |
391 | |
392 | out_free: |
393 | while (l != NULL) { |
394 | next = l->next; |
395 | kfree(objp: l); |
396 | l = next; |
397 | } |
398 | mips_hi16_list = NULL; |
399 | |
400 | return -ENOEXEC; |
401 | } |
402 | |
403 | static int (*reloc_handlers[]) (struct module *me, uint32_t *location, |
404 | Elf32_Addr v) = { |
405 | [R_MIPS_NONE] = apply_r_mips_none, |
406 | [R_MIPS_32] = apply_r_mips_32, |
407 | [R_MIPS_26] = apply_r_mips_26, |
408 | [R_MIPS_HI16] = apply_r_mips_hi16, |
409 | [R_MIPS_LO16] = apply_r_mips_lo16, |
410 | [R_MIPS_GPREL16] = apply_r_mips_gprel16, |
411 | [R_MIPS_PC16] = apply_r_mips_pc16 |
412 | }; |
413 | |
414 | static char *rstrs[] = { |
415 | [R_MIPS_NONE] = "MIPS_NONE" , |
416 | [R_MIPS_32] = "MIPS_32" , |
417 | [R_MIPS_26] = "MIPS_26" , |
418 | [R_MIPS_HI16] = "MIPS_HI16" , |
419 | [R_MIPS_LO16] = "MIPS_LO16" , |
420 | [R_MIPS_GPREL16] = "MIPS_GPREL16" , |
421 | [R_MIPS_PC16] = "MIPS_PC16" |
422 | }; |
423 | |
424 | static int apply_relocations(Elf32_Shdr *sechdrs, |
425 | const char *strtab, |
426 | unsigned int symindex, |
427 | unsigned int relsec, |
428 | struct module *me) |
429 | { |
430 | Elf32_Rel *rel = (void *) sechdrs[relsec].sh_addr; |
431 | Elf32_Sym *sym; |
432 | uint32_t *location; |
433 | unsigned int i; |
434 | Elf32_Addr v; |
435 | int res; |
436 | |
437 | for (i = 0; i < sechdrs[relsec].sh_size / sizeof(*rel); i++) { |
438 | Elf32_Word r_info = rel[i].r_info; |
439 | |
440 | /* This is where to make the change */ |
441 | location = (void *)sechdrs[sechdrs[relsec].sh_info].sh_addr |
442 | + rel[i].r_offset; |
443 | /* This is the symbol it is referring to */ |
444 | sym = (Elf32_Sym *)sechdrs[symindex].sh_addr |
445 | + ELF32_R_SYM(r_info); |
446 | |
447 | if (!sym->st_value) { |
448 | pr_debug("%s: undefined weak symbol %s\n" , |
449 | me->name, strtab + sym->st_name); |
450 | /* just print the warning, dont barf */ |
451 | } |
452 | |
453 | v = sym->st_value; |
454 | |
455 | res = reloc_handlers[ELF32_R_TYPE(r_info)](me, location, v); |
456 | if (res) { |
457 | char *r = rstrs[ELF32_R_TYPE(r_info)]; |
458 | pr_warn("VPE loader: .text+0x%x relocation type %s for symbol \"%s\" failed\n" , |
459 | rel[i].r_offset, r ? r : "UNKNOWN" , |
460 | strtab + sym->st_name); |
461 | return res; |
462 | } |
463 | } |
464 | |
465 | return 0; |
466 | } |
467 | |
468 | static inline void save_gp_address(unsigned int secbase, unsigned int rel) |
469 | { |
470 | gp_addr = secbase + rel; |
471 | gp_offs = gp_addr - (secbase & 0xffff0000); |
472 | } |
473 | /* end module-elf32.c */ |
474 | |
475 | /* Change all symbols so that sh_value encodes the pointer directly. */ |
476 | static void simplify_symbols(Elf_Shdr *sechdrs, |
477 | unsigned int symindex, |
478 | const char *strtab, |
479 | const char *secstrings, |
480 | unsigned int nsecs, struct module *mod) |
481 | { |
482 | Elf_Sym *sym = (void *)sechdrs[symindex].sh_addr; |
483 | unsigned long secbase, bssbase = 0; |
484 | unsigned int i, n = sechdrs[symindex].sh_size / sizeof(Elf_Sym); |
485 | int size; |
486 | |
487 | /* find the .bss section for COMMON symbols */ |
488 | for (i = 0; i < nsecs; i++) { |
489 | if (strncmp(secstrings + sechdrs[i].sh_name, ".bss" , 4) == 0) { |
490 | bssbase = sechdrs[i].sh_addr; |
491 | break; |
492 | } |
493 | } |
494 | |
495 | for (i = 1; i < n; i++) { |
496 | switch (sym[i].st_shndx) { |
497 | case SHN_COMMON: |
498 | /* Allocate space for the symbol in the .bss section. |
499 | st_value is currently size. |
500 | We want it to have the address of the symbol. */ |
501 | |
502 | size = sym[i].st_value; |
503 | sym[i].st_value = bssbase; |
504 | |
505 | bssbase += size; |
506 | break; |
507 | |
508 | case SHN_ABS: |
509 | /* Don't need to do anything */ |
510 | break; |
511 | |
512 | case SHN_UNDEF: |
513 | /* ret = -ENOENT; */ |
514 | break; |
515 | |
516 | case SHN_MIPS_SCOMMON: |
517 | pr_debug("simplify_symbols: ignoring SHN_MIPS_SCOMMON symbol <%s> st_shndx %d\n" , |
518 | strtab + sym[i].st_name, sym[i].st_shndx); |
519 | /* .sbss section */ |
520 | break; |
521 | |
522 | default: |
523 | secbase = sechdrs[sym[i].st_shndx].sh_addr; |
524 | |
525 | if (strncmp(strtab + sym[i].st_name, "_gp" , 3) == 0) |
526 | save_gp_address(secbase, rel: sym[i].st_value); |
527 | |
528 | sym[i].st_value += secbase; |
529 | break; |
530 | } |
531 | } |
532 | } |
533 | |
534 | #ifdef DEBUG_ELFLOADER |
535 | static void dump_elfsymbols(Elf_Shdr *sechdrs, unsigned int symindex, |
536 | const char *strtab, struct module *mod) |
537 | { |
538 | Elf_Sym *sym = (void *)sechdrs[symindex].sh_addr; |
539 | unsigned int i, n = sechdrs[symindex].sh_size / sizeof(Elf_Sym); |
540 | |
541 | pr_debug("dump_elfsymbols: n %d\n" , n); |
542 | for (i = 1; i < n; i++) { |
543 | pr_debug(" i %d name <%s> 0x%x\n" , i, strtab + sym[i].st_name, |
544 | sym[i].st_value); |
545 | } |
546 | } |
547 | #endif |
548 | |
549 | static int find_vpe_symbols(struct vpe *v, Elf_Shdr *sechdrs, |
550 | unsigned int symindex, const char *strtab, |
551 | struct module *mod) |
552 | { |
553 | Elf_Sym *sym = (void *)sechdrs[symindex].sh_addr; |
554 | unsigned int i, n = sechdrs[symindex].sh_size / sizeof(Elf_Sym); |
555 | |
556 | for (i = 1; i < n; i++) { |
557 | if (strcmp(strtab + sym[i].st_name, "__start" ) == 0) |
558 | v->__start = sym[i].st_value; |
559 | |
560 | if (strcmp(strtab + sym[i].st_name, "vpe_shared" ) == 0) |
561 | v->shared_ptr = (void *)sym[i].st_value; |
562 | } |
563 | |
564 | if ((v->__start == 0) || (v->shared_ptr == NULL)) |
565 | return -1; |
566 | |
567 | return 0; |
568 | } |
569 | |
570 | /* |
571 | * Allocates a VPE with some program code space(the load address), copies the |
572 | * contents of the program (p)buffer performing relocatations/etc, free's it |
573 | * when finished. |
574 | */ |
575 | static int vpe_elfload(struct vpe *v) |
576 | { |
577 | Elf_Ehdr *hdr; |
578 | Elf_Shdr *sechdrs; |
579 | long err = 0; |
580 | char *secstrings, *strtab = NULL; |
581 | unsigned int len, i, symindex = 0, strindex = 0, relocate = 0; |
582 | struct module mod; /* so we can re-use the relocations code */ |
583 | |
584 | memset(&mod, 0, sizeof(struct module)); |
585 | strcpy(p: mod.name, q: "VPE loader" ); |
586 | |
587 | hdr = (Elf_Ehdr *) v->pbuffer; |
588 | len = v->plen; |
589 | |
590 | /* Sanity checks against insmoding binaries or wrong arch, |
591 | weird elf version */ |
592 | if (memcmp(p: hdr->e_ident, ELFMAG, SELFMAG) != 0 |
593 | || (hdr->e_type != ET_REL && hdr->e_type != ET_EXEC) |
594 | || !elf_check_arch(hdr) |
595 | || hdr->e_shentsize != sizeof(*sechdrs)) { |
596 | pr_warn("VPE loader: program wrong arch or weird elf version\n" ); |
597 | |
598 | return -ENOEXEC; |
599 | } |
600 | |
601 | if (hdr->e_type == ET_REL) |
602 | relocate = 1; |
603 | |
604 | if (len < hdr->e_shoff + hdr->e_shnum * sizeof(Elf_Shdr)) { |
605 | pr_err("VPE loader: program length %u truncated\n" , len); |
606 | |
607 | return -ENOEXEC; |
608 | } |
609 | |
610 | /* Convenience variables */ |
611 | sechdrs = (void *)hdr + hdr->e_shoff; |
612 | secstrings = (void *)hdr + sechdrs[hdr->e_shstrndx].sh_offset; |
613 | sechdrs[0].sh_addr = 0; |
614 | |
615 | /* And these should exist, but gcc whinges if we don't init them */ |
616 | symindex = strindex = 0; |
617 | |
618 | if (relocate) { |
619 | for (i = 1; i < hdr->e_shnum; i++) { |
620 | if ((sechdrs[i].sh_type != SHT_NOBITS) && |
621 | (len < sechdrs[i].sh_offset + sechdrs[i].sh_size)) { |
622 | pr_err("VPE program length %u truncated\n" , |
623 | len); |
624 | return -ENOEXEC; |
625 | } |
626 | |
627 | /* Mark all sections sh_addr with their address in the |
628 | temporary image. */ |
629 | sechdrs[i].sh_addr = (size_t) hdr + |
630 | sechdrs[i].sh_offset; |
631 | |
632 | /* Internal symbols and strings. */ |
633 | if (sechdrs[i].sh_type == SHT_SYMTAB) { |
634 | symindex = i; |
635 | strindex = sechdrs[i].sh_link; |
636 | strtab = (char *)hdr + |
637 | sechdrs[strindex].sh_offset; |
638 | } |
639 | } |
640 | layout_sections(mod: &mod, hdr, sechdrs, secstrings); |
641 | } |
642 | |
643 | v->load_addr = alloc_progmem(len: mod.mem[MOD_TEXT].size); |
644 | if (!v->load_addr) |
645 | return -ENOMEM; |
646 | |
647 | pr_info("VPE loader: loading to %p\n" , v->load_addr); |
648 | |
649 | if (relocate) { |
650 | for (i = 0; i < hdr->e_shnum; i++) { |
651 | void *dest; |
652 | |
653 | if (!(sechdrs[i].sh_flags & SHF_ALLOC)) |
654 | continue; |
655 | |
656 | dest = v->load_addr + sechdrs[i].sh_entsize; |
657 | |
658 | if (sechdrs[i].sh_type != SHT_NOBITS) |
659 | memcpy(dest, (void *)sechdrs[i].sh_addr, |
660 | sechdrs[i].sh_size); |
661 | /* Update sh_addr to point to copy in image. */ |
662 | sechdrs[i].sh_addr = (unsigned long)dest; |
663 | |
664 | pr_debug(" section sh_name %s sh_addr 0x%x\n" , |
665 | secstrings + sechdrs[i].sh_name, |
666 | sechdrs[i].sh_addr); |
667 | } |
668 | |
669 | /* Fix up syms, so that st_value is a pointer to location. */ |
670 | simplify_symbols(sechdrs, symindex, strtab, secstrings, |
671 | nsecs: hdr->e_shnum, mod: &mod); |
672 | |
673 | /* Now do relocations. */ |
674 | for (i = 1; i < hdr->e_shnum; i++) { |
675 | const char *strtab = (char *)sechdrs[strindex].sh_addr; |
676 | unsigned int info = sechdrs[i].sh_info; |
677 | |
678 | /* Not a valid relocation section? */ |
679 | if (info >= hdr->e_shnum) |
680 | continue; |
681 | |
682 | /* Don't bother with non-allocated sections */ |
683 | if (!(sechdrs[info].sh_flags & SHF_ALLOC)) |
684 | continue; |
685 | |
686 | if (sechdrs[i].sh_type == SHT_REL) |
687 | err = apply_relocations(sechdrs, strtab, |
688 | symindex, relsec: i, me: &mod); |
689 | else if (sechdrs[i].sh_type == SHT_RELA) |
690 | err = apply_relocate_add(sechdrs, strtab, |
691 | symindex, relsec: i, mod: &mod); |
692 | if (err < 0) |
693 | return err; |
694 | |
695 | } |
696 | } else { |
697 | struct elf_phdr *phdr = (struct elf_phdr *) |
698 | ((char *)hdr + hdr->e_phoff); |
699 | |
700 | for (i = 0; i < hdr->e_phnum; i++) { |
701 | if (phdr->p_type == PT_LOAD) { |
702 | memcpy((void *)phdr->p_paddr, |
703 | (char *)hdr + phdr->p_offset, |
704 | phdr->p_filesz); |
705 | memset((void *)phdr->p_paddr + phdr->p_filesz, |
706 | 0, phdr->p_memsz - phdr->p_filesz); |
707 | } |
708 | phdr++; |
709 | } |
710 | |
711 | for (i = 0; i < hdr->e_shnum; i++) { |
712 | /* Internal symbols and strings. */ |
713 | if (sechdrs[i].sh_type == SHT_SYMTAB) { |
714 | symindex = i; |
715 | strindex = sechdrs[i].sh_link; |
716 | strtab = (char *)hdr + |
717 | sechdrs[strindex].sh_offset; |
718 | |
719 | /* |
720 | * mark symtab's address for when we try |
721 | * to find the magic symbols |
722 | */ |
723 | sechdrs[i].sh_addr = (size_t) hdr + |
724 | sechdrs[i].sh_offset; |
725 | } |
726 | } |
727 | } |
728 | |
729 | /* make sure it's physically written out */ |
730 | flush_icache_range(start: (unsigned long)v->load_addr, |
731 | end: (unsigned long)v->load_addr + v->len); |
732 | |
733 | if ((find_vpe_symbols(v, sechdrs, symindex, strtab, mod: &mod)) < 0) { |
734 | if (v->__start == 0) { |
735 | pr_warn("VPE loader: program does not contain a __start symbol\n" ); |
736 | return -ENOEXEC; |
737 | } |
738 | |
739 | if (v->shared_ptr == NULL) |
740 | pr_warn("VPE loader: program does not contain vpe_shared symbol.\n" |
741 | " Unable to use AMVP (AP/SP) facilities.\n" ); |
742 | } |
743 | |
744 | pr_info(" elf loaded\n" ); |
745 | return 0; |
746 | } |
747 | |
748 | /* checks VPE is unused and gets ready to load program */ |
749 | static int vpe_open(struct inode *inode, struct file *filp) |
750 | { |
751 | enum vpe_state state; |
752 | struct vpe_notifications *notifier; |
753 | struct vpe *v; |
754 | |
755 | if (VPE_MODULE_MINOR != iminor(inode)) { |
756 | /* assume only 1 device at the moment. */ |
757 | pr_warn("VPE loader: only vpe1 is supported\n" ); |
758 | |
759 | return -ENODEV; |
760 | } |
761 | |
762 | v = get_vpe(minor: aprp_cpu_index()); |
763 | if (v == NULL) { |
764 | pr_warn("VPE loader: unable to get vpe\n" ); |
765 | |
766 | return -ENODEV; |
767 | } |
768 | |
769 | state = xchg(&v->state, VPE_STATE_INUSE); |
770 | if (state != VPE_STATE_UNUSED) { |
771 | pr_debug("VPE loader: tc in use dumping regs\n" ); |
772 | |
773 | list_for_each_entry(notifier, &v->notify, list) |
774 | notifier->stop(aprp_cpu_index()); |
775 | |
776 | release_progmem(v->load_addr); |
777 | cleanup_tc(get_tc(index: aprp_cpu_index())); |
778 | } |
779 | |
780 | /* this of-course trashes what was there before... */ |
781 | v->pbuffer = vmalloc(size: P_SIZE); |
782 | if (!v->pbuffer) { |
783 | pr_warn("VPE loader: unable to allocate memory\n" ); |
784 | return -ENOMEM; |
785 | } |
786 | v->plen = P_SIZE; |
787 | v->load_addr = NULL; |
788 | v->len = 0; |
789 | v->shared_ptr = NULL; |
790 | v->__start = 0; |
791 | |
792 | return 0; |
793 | } |
794 | |
795 | static int vpe_release(struct inode *inode, struct file *filp) |
796 | { |
797 | #ifdef CONFIG_MIPS_VPE_LOADER_MT |
798 | struct vpe *v; |
799 | Elf_Ehdr *hdr; |
800 | int ret = 0; |
801 | |
802 | v = get_vpe(aprp_cpu_index()); |
803 | if (v == NULL) |
804 | return -ENODEV; |
805 | |
806 | hdr = (Elf_Ehdr *) v->pbuffer; |
807 | if (memcmp(hdr->e_ident, ELFMAG, SELFMAG) == 0) { |
808 | if (vpe_elfload(v) >= 0) { |
809 | vpe_run(v); |
810 | } else { |
811 | pr_warn("VPE loader: ELF load failed.\n" ); |
812 | ret = -ENOEXEC; |
813 | } |
814 | } else { |
815 | pr_warn("VPE loader: only elf files are supported\n" ); |
816 | ret = -ENOEXEC; |
817 | } |
818 | |
819 | /* It's good to be able to run the SP and if it chokes have a look at |
820 | the /dev/rt?. But if we reset the pointer to the shared struct we |
821 | lose what has happened. So perhaps if garbage is sent to the vpe |
822 | device, use it as a trigger for the reset. Hopefully a nice |
823 | executable will be along shortly. */ |
824 | if (ret < 0) |
825 | v->shared_ptr = NULL; |
826 | |
827 | vfree(v->pbuffer); |
828 | v->plen = 0; |
829 | |
830 | return ret; |
831 | #else |
832 | pr_warn("VPE loader: ELF load failed.\n" ); |
833 | return -ENOEXEC; |
834 | #endif |
835 | } |
836 | |
837 | static ssize_t vpe_write(struct file *file, const char __user *buffer, |
838 | size_t count, loff_t *ppos) |
839 | { |
840 | size_t ret = count; |
841 | struct vpe *v; |
842 | |
843 | if (iminor(inode: file_inode(f: file)) != VPE_MODULE_MINOR) |
844 | return -ENODEV; |
845 | |
846 | v = get_vpe(minor: aprp_cpu_index()); |
847 | |
848 | if (v == NULL) |
849 | return -ENODEV; |
850 | |
851 | if ((count + v->len) > v->plen) { |
852 | pr_warn("VPE loader: elf size too big. Perhaps strip unneeded symbols\n" ); |
853 | return -ENOMEM; |
854 | } |
855 | |
856 | count -= copy_from_user(to: v->pbuffer + v->len, from: buffer, n: count); |
857 | if (!count) |
858 | return -EFAULT; |
859 | |
860 | v->len += count; |
861 | return ret; |
862 | } |
863 | |
864 | const struct file_operations vpe_fops = { |
865 | .owner = THIS_MODULE, |
866 | .open = vpe_open, |
867 | .release = vpe_release, |
868 | .write = vpe_write, |
869 | .llseek = noop_llseek, |
870 | }; |
871 | |
872 | void *vpe_get_shared(int index) |
873 | { |
874 | struct vpe *v = get_vpe(minor: index); |
875 | |
876 | if (v == NULL) |
877 | return NULL; |
878 | |
879 | return v->shared_ptr; |
880 | } |
881 | EXPORT_SYMBOL(vpe_get_shared); |
882 | |
883 | int vpe_notify(int index, struct vpe_notifications *notify) |
884 | { |
885 | struct vpe *v = get_vpe(minor: index); |
886 | |
887 | if (v == NULL) |
888 | return -1; |
889 | |
890 | list_add(new: ¬ify->list, head: &v->notify); |
891 | return 0; |
892 | } |
893 | EXPORT_SYMBOL(vpe_notify); |
894 | |
895 | module_init(vpe_module_init); |
896 | module_exit(vpe_module_exit); |
897 | MODULE_DESCRIPTION("MIPS VPE Loader" ); |
898 | MODULE_AUTHOR("Elizabeth Oldham, MIPS Technologies, Inc." ); |
899 | MODULE_LICENSE("GPL" ); |
900 | |