1 /* Kernel dynamically loadable module help for PARISC.
3 * The best reference for this stuff is probably the Processor-
4 * Specific ELF Supplement for PA-RISC:
5 * http://ftp.parisc-linux.org/docs/arch/elf-pa-hp.pdf
7 * Linux/PA-RISC Project (http://www.parisc-linux.org/)
8 * Copyright (C) 2003 Randolph Chung <tausq at debian . org>
9 * Copyright (C) 2008 Helge Deller <deller@gmx.de>
12 * This program is free software; you can redistribute it and/or modify
13 * it under the terms of the GNU General Public License as published by
14 * the Free Software Foundation; either version 2 of the License, or
15 * (at your option) any later version.
17 * This program is distributed in the hope that it will be useful,
18 * but WITHOUT ANY WARRANTY; without even the implied warranty of
19 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
20 * GNU General Public License for more details.
22 * You should have received a copy of the GNU General Public License
23 * along with this program; if not, write to the Free Software
24 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
29 * On 32bit (and sometimes 64bit) and with big kernel modules like xfs or
30 * ipv6 the relocation types R_PARISC_PCREL17F and R_PARISC_PCREL22F may
31 * fail to reach their PLT stub if we only create one big stub array for
32 * all sections at the beginning of the core or init section.
33 * Instead we now insert individual PLT stub entries directly in front of
34 * of the code sections where the stubs are actually called.
35 * This reduces the distance between the PCREL location and the stub entry
36 * so that the relocations can be fulfilled.
37 * While calculating the final layout of the kernel module in memory, the
38 * kernel module loader calls arch_mod_section_prepend() to request the
39 * to be reserved amount of memory in front of each individual section.
42 * We are not doing SEGREL32 handling correctly. According to the ABI, we
43 * should do a value offset, like this:
44 * if (in_init(me, (void *)val))
45 * val -= (uint32_t)me->module_init;
47 * val -= (uint32_t)me->module_core;
48 * However, SEGREL32 is used only for PARISC unwind entries, and we want
49 * those entries to have an absolute address, and not just an offset.
51 * The unwind table mechanism has the ability to specify an offset for
52 * the unwind table; however, because we split off the init functions into
53 * a different piece of memory, it is not possible to do this using a
54 * single offset. Instead, we use the above hack for now.
57 #include <linux/moduleloader.h>
58 #include <linux/elf.h>
59 #include <linux/vmalloc.h>
61 #include <linux/string.h>
62 #include <linux/kernel.h>
63 #include <linux/bug.h>
64 #include <linux/uaccess.h>
66 #include <asm/sections.h>
67 #include <asm/unwind.h>
72 #define DEBUGP(fmt...)
75 #define RELOC_REACHABLE(val, bits) \
76 (( ( !((val) & (1<<((bits)-1))) && ((val)>>(bits)) != 0 ) || \
77 ( ((val) & (1<<((bits)-1))) && ((val)>>(bits)) != (((__typeof__(val))(~0))>>((bits)+2)))) ? \
80 #define CHECK_RELOC(val, bits) \
81 if (!RELOC_REACHABLE(val, bits)) { \
82 printk(KERN_ERR "module %s relocation of symbol %s is out of range (0x%lx in %d bits)\n", \
83 me->name, strtab + sym->st_name, (unsigned long)val, bits); \
87 /* Maximum number of GOT entries. We use a long displacement ldd from
88 * the bottom of the table, which has a maximum signed displacement of
89 * 0x3fff; however, since we're only going forward, this becomes
90 * 0x1fff, and thus, since each GOT entry is 8 bytes long we can have
91 * at most 1023 entries */
94 /* three functions to determine where in the module core
95 * or init pieces the location is */
96 static inline int in_init(struct module
*me
, void *loc
)
98 return (loc
>= me
->module_init
&&
99 loc
<= (me
->module_init
+ me
->init_size
));
102 static inline int in_core(struct module
*me
, void *loc
)
104 return (loc
>= me
->module_core
&&
105 loc
<= (me
->module_core
+ me
->core_size
));
108 static inline int in_local(struct module
*me
, void *loc
)
110 return in_init(me
, loc
) || in_core(me
, loc
);
118 #define Elf_Fdesc Elf32_Fdesc
121 Elf32_Word insns
[2]; /* each stub entry has two insns */
128 #define Elf_Fdesc Elf64_Fdesc
131 Elf64_Word insns
[4]; /* each stub entry has four insns */
135 /* Field selection types defined by hppa */
136 #define rnd(x) (((x)+0x1000)&~0x1fff)
137 /* fsel: full 32 bits */
138 #define fsel(v,a) ((v)+(a))
139 /* lsel: select left 21 bits */
140 #define lsel(v,a) (((v)+(a))>>11)
141 /* rsel: select right 11 bits */
142 #define rsel(v,a) (((v)+(a))&0x7ff)
143 /* lrsel with rounding of addend to nearest 8k */
144 #define lrsel(v,a) (((v)+rnd(a))>>11)
145 /* rrsel with rounding of addend to nearest 8k */
146 #define rrsel(v,a) ((((v)+rnd(a))&0x7ff)+((a)-rnd(a)))
148 #define mask(x,sz) ((x) & ~((1<<(sz))-1))
151 /* The reassemble_* functions prepare an immediate value for
152 insertion into an opcode. pa-risc uses all sorts of weird bitfields
153 in the instruction to hold the value. */
154 static inline int reassemble_14(int as14
)
156 return (((as14
& 0x1fff) << 1) |
157 ((as14
& 0x2000) >> 13));
160 static inline int reassemble_17(int as17
)
162 return (((as17
& 0x10000) >> 16) |
163 ((as17
& 0x0f800) << 5) |
164 ((as17
& 0x00400) >> 8) |
165 ((as17
& 0x003ff) << 3));
168 static inline int reassemble_21(int as21
)
170 return (((as21
& 0x100000) >> 20) |
171 ((as21
& 0x0ffe00) >> 8) |
172 ((as21
& 0x000180) << 7) |
173 ((as21
& 0x00007c) << 14) |
174 ((as21
& 0x000003) << 12));
177 static inline int reassemble_22(int as22
)
179 return (((as22
& 0x200000) >> 21) |
180 ((as22
& 0x1f0000) << 5) |
181 ((as22
& 0x00f800) << 5) |
182 ((as22
& 0x000400) >> 8) |
183 ((as22
& 0x0003ff) << 3));
186 void *module_alloc(unsigned long size
)
190 return vmalloc(size
);
194 static inline unsigned long count_gots(const Elf_Rela
*rela
, unsigned long n
)
199 static inline unsigned long count_fdescs(const Elf_Rela
*rela
, unsigned long n
)
204 static inline unsigned long count_stubs(const Elf_Rela
*rela
, unsigned long n
)
206 unsigned long cnt
= 0;
208 for (; n
> 0; n
--, rela
++)
210 switch (ELF32_R_TYPE(rela
->r_info
)) {
211 case R_PARISC_PCREL17F
:
212 case R_PARISC_PCREL22F
:
220 static inline unsigned long count_gots(const Elf_Rela
*rela
, unsigned long n
)
222 unsigned long cnt
= 0;
224 for (; n
> 0; n
--, rela
++)
226 switch (ELF64_R_TYPE(rela
->r_info
)) {
227 case R_PARISC_LTOFF21L
:
228 case R_PARISC_LTOFF14R
:
229 case R_PARISC_PCREL22F
:
237 static inline unsigned long count_fdescs(const Elf_Rela
*rela
, unsigned long n
)
239 unsigned long cnt
= 0;
241 for (; n
> 0; n
--, rela
++)
243 switch (ELF64_R_TYPE(rela
->r_info
)) {
244 case R_PARISC_FPTR64
:
252 static inline unsigned long count_stubs(const Elf_Rela
*rela
, unsigned long n
)
254 unsigned long cnt
= 0;
256 for (; n
> 0; n
--, rela
++)
258 switch (ELF64_R_TYPE(rela
->r_info
)) {
259 case R_PARISC_PCREL22F
:
269 /* Free memory returned from module_alloc */
270 void module_free(struct module
*mod
, void *module_region
)
272 kfree(mod
->arch
.section
);
273 mod
->arch
.section
= NULL
;
275 vfree(module_region
);
276 /* FIXME: If module_region == mod->init_region, trim exception
280 /* Additional bytes needed in front of individual sections */
281 unsigned int arch_mod_section_prepend(struct module
*mod
,
282 unsigned int section
)
284 /* size needed for all stubs of this section (including
285 * one additional for correct alignment of the stubs) */
286 return (mod
->arch
.section
[section
].stub_entries
+ 1)
287 * sizeof(struct stub_entry
);
291 int module_frob_arch_sections(CONST Elf_Ehdr
*hdr
,
292 CONST Elf_Shdr
*sechdrs
,
293 CONST
char *secstrings
,
296 unsigned long gots
= 0, fdescs
= 0, len
;
299 len
= hdr
->e_shnum
* sizeof(me
->arch
.section
[0]);
300 me
->arch
.section
= kzalloc(len
, GFP_KERNEL
);
301 if (!me
->arch
.section
)
304 for (i
= 1; i
< hdr
->e_shnum
; i
++) {
305 const Elf_Rela
*rels
= (void *)sechdrs
[i
].sh_addr
;
306 unsigned long nrels
= sechdrs
[i
].sh_size
/ sizeof(*rels
);
307 unsigned int count
, s
;
309 if (strncmp(secstrings
+ sechdrs
[i
].sh_name
,
310 ".PARISC.unwind", 14) == 0)
311 me
->arch
.unwind_section
= i
;
313 if (sechdrs
[i
].sh_type
!= SHT_RELA
)
316 /* some of these are not relevant for 32-bit/64-bit
317 * we leave them here to make the code common. the
318 * compiler will do its thing and optimize out the
319 * stuff we don't need
321 gots
+= count_gots(rels
, nrels
);
322 fdescs
+= count_fdescs(rels
, nrels
);
324 /* XXX: By sorting the relocs and finding duplicate entries
325 * we could reduce the number of necessary stubs and save
327 count
= count_stubs(rels
, nrels
);
331 /* so we need relocation stubs. reserve necessary memory. */
332 /* sh_info gives the section for which we need to add stubs. */
333 s
= sechdrs
[i
].sh_info
;
335 /* each code section should only have one relocation section */
336 WARN_ON(me
->arch
.section
[s
].stub_entries
);
338 /* store number of stubs we need for this section */
339 me
->arch
.section
[s
].stub_entries
+= count
;
342 /* align things a bit */
343 me
->core_size
= ALIGN(me
->core_size
, 16);
344 me
->arch
.got_offset
= me
->core_size
;
345 me
->core_size
+= gots
* sizeof(struct got_entry
);
347 me
->core_size
= ALIGN(me
->core_size
, 16);
348 me
->arch
.fdesc_offset
= me
->core_size
;
349 me
->core_size
+= fdescs
* sizeof(Elf_Fdesc
);
351 me
->arch
.got_max
= gots
;
352 me
->arch
.fdesc_max
= fdescs
;
358 static Elf64_Word
get_got(struct module
*me
, unsigned long value
, long addend
)
361 struct got_entry
*got
;
367 got
= me
->module_core
+ me
->arch
.got_offset
;
368 for (i
= 0; got
[i
].addr
; i
++)
369 if (got
[i
].addr
== value
)
372 BUG_ON(++me
->arch
.got_count
> me
->arch
.got_max
);
376 DEBUGP("GOT ENTRY %d[%x] val %lx\n", i
, i
*sizeof(struct got_entry
),
378 return i
* sizeof(struct got_entry
);
380 #endif /* CONFIG_64BIT */
383 static Elf_Addr
get_fdesc(struct module
*me
, unsigned long value
)
385 Elf_Fdesc
*fdesc
= me
->module_core
+ me
->arch
.fdesc_offset
;
388 printk(KERN_ERR
"%s: zero OPD requested!\n", me
->name
);
392 /* Look for existing fdesc entry. */
393 while (fdesc
->addr
) {
394 if (fdesc
->addr
== value
)
395 return (Elf_Addr
)fdesc
;
399 BUG_ON(++me
->arch
.fdesc_count
> me
->arch
.fdesc_max
);
403 fdesc
->gp
= (Elf_Addr
)me
->module_core
+ me
->arch
.got_offset
;
404 return (Elf_Addr
)fdesc
;
406 #endif /* CONFIG_64BIT */
414 static Elf_Addr
get_stub(struct module
*me
, unsigned long value
, long addend
,
415 enum elf_stub_type stub_type
, Elf_Addr loc0
, unsigned int targetsec
)
417 struct stub_entry
*stub
;
419 /* initialize stub_offset to point in front of the section */
420 if (!me
->arch
.section
[targetsec
].stub_offset
) {
421 loc0
-= (me
->arch
.section
[targetsec
].stub_entries
+ 1) *
422 sizeof(struct stub_entry
);
423 /* get correct alignment for the stubs */
424 loc0
= ALIGN(loc0
, sizeof(struct stub_entry
));
425 me
->arch
.section
[targetsec
].stub_offset
= loc0
;
428 /* get address of stub entry */
429 stub
= (void *) me
->arch
.section
[targetsec
].stub_offset
;
430 me
->arch
.section
[targetsec
].stub_offset
+= sizeof(struct stub_entry
);
432 /* do not write outside available stub area */
433 BUG_ON(0 == me
->arch
.section
[targetsec
].stub_entries
--);
437 /* for 32-bit the stub looks like this:
439 * be,n R'XXX(%sr4,%r1)
441 //value = *(unsigned long *)((value + addend) & ~3); /* why? */
443 stub
->insns
[0] = 0x20200000; /* ldil L'XXX,%r1 */
444 stub
->insns
[1] = 0xe0202002; /* be,n R'XXX(%sr4,%r1) */
446 stub
->insns
[0] |= reassemble_21(lrsel(value
, addend
));
447 stub
->insns
[1] |= reassemble_17(rrsel(value
, addend
) / 4);
450 /* for 64-bit we have three kinds of stubs:
451 * for normal function calls:
463 * for direct branches (jumps between different section of the
471 stub
->insns
[0] = 0x537b0000; /* ldd 0(%dp),%dp */
472 stub
->insns
[1] = 0x53610020; /* ldd 10(%dp),%r1 */
473 stub
->insns
[2] = 0xe820d000; /* bve (%r1) */
474 stub
->insns
[3] = 0x537b0030; /* ldd 18(%dp),%dp */
476 stub
->insns
[0] |= reassemble_14(get_got(me
, value
, addend
) & 0x3fff);
479 stub
->insns
[0] = 0x20200000; /* ldil 0,%r1 */
480 stub
->insns
[1] = 0x34210000; /* ldo 0(%r1), %r1 */
481 stub
->insns
[2] = 0x50210020; /* ldd 10(%r1),%r1 */
482 stub
->insns
[3] = 0xe820d002; /* bve,n (%r1) */
484 stub
->insns
[0] |= reassemble_21(lrsel(value
, addend
));
485 stub
->insns
[1] |= reassemble_14(rrsel(value
, addend
));
487 case ELF_STUB_DIRECT
:
488 stub
->insns
[0] = 0x20200000; /* ldil 0,%r1 */
489 stub
->insns
[1] = 0x34210000; /* ldo 0(%r1), %r1 */
490 stub
->insns
[2] = 0xe820d002; /* bve,n (%r1) */
492 stub
->insns
[0] |= reassemble_21(lrsel(value
, addend
));
493 stub
->insns
[1] |= reassemble_14(rrsel(value
, addend
));
499 return (Elf_Addr
)stub
;
502 int apply_relocate(Elf_Shdr
*sechdrs
,
504 unsigned int symindex
,
508 /* parisc should not need this ... */
509 printk(KERN_ERR
"module %s: RELOCATION unsupported\n",
515 int apply_relocate_add(Elf_Shdr
*sechdrs
,
517 unsigned int symindex
,
522 Elf32_Rela
*rel
= (void *)sechdrs
[relsec
].sh_addr
;
529 unsigned int targetsec
= sechdrs
[relsec
].sh_info
;
530 //unsigned long dp = (unsigned long)$global$;
531 register unsigned long dp
asm ("r27");
533 DEBUGP("Applying relocate section %u to %u\n", relsec
,
535 for (i
= 0; i
< sechdrs
[relsec
].sh_size
/ sizeof(*rel
); i
++) {
536 /* This is where to make the change */
537 loc
= (void *)sechdrs
[targetsec
].sh_addr
539 /* This is the start of the target section */
540 loc0
= sechdrs
[targetsec
].sh_addr
;
541 /* This is the symbol it is referring to */
542 sym
= (Elf32_Sym
*)sechdrs
[symindex
].sh_addr
543 + ELF32_R_SYM(rel
[i
].r_info
);
544 if (!sym
->st_value
) {
545 printk(KERN_WARNING
"%s: Unknown symbol %s\n",
546 me
->name
, strtab
+ sym
->st_name
);
549 //dot = (sechdrs[relsec].sh_addr + rel->r_offset) & ~0x03;
550 dot
= (Elf32_Addr
)loc
& ~0x03;
553 addend
= rel
[i
].r_addend
;
556 #define r(t) ELF32_R_TYPE(rel[i].r_info)==t ? #t :
557 DEBUGP("Symbol %s loc 0x%x val 0x%x addend 0x%x: %s\n",
558 strtab
+ sym
->st_name
,
559 (uint32_t)loc
, val
, addend
,
573 switch (ELF32_R_TYPE(rel
[i
].r_info
)) {
574 case R_PARISC_PLABEL32
:
575 /* 32-bit function address */
576 /* no function descriptors... */
577 *loc
= fsel(val
, addend
);
580 /* direct 32-bit ref */
581 *loc
= fsel(val
, addend
);
583 case R_PARISC_DIR21L
:
584 /* left 21 bits of effective address */
585 val
= lrsel(val
, addend
);
586 *loc
= mask(*loc
, 21) | reassemble_21(val
);
588 case R_PARISC_DIR14R
:
589 /* right 14 bits of effective address */
590 val
= rrsel(val
, addend
);
591 *loc
= mask(*loc
, 14) | reassemble_14(val
);
593 case R_PARISC_SEGREL32
:
594 /* 32-bit segment relative address */
595 /* See note about special handling of SEGREL32 at
596 * the beginning of this file.
598 *loc
= fsel(val
, addend
);
600 case R_PARISC_DPREL21L
:
601 /* left 21 bit of relative address */
602 val
= lrsel(val
- dp
, addend
);
603 *loc
= mask(*loc
, 21) | reassemble_21(val
);
605 case R_PARISC_DPREL14R
:
606 /* right 14 bit of relative address */
607 val
= rrsel(val
- dp
, addend
);
608 *loc
= mask(*loc
, 14) | reassemble_14(val
);
610 case R_PARISC_PCREL17F
:
611 /* 17-bit PC relative address */
612 /* calculate direct call offset */
614 val
= (val
- dot
- 8)/4;
615 if (!RELOC_REACHABLE(val
, 17)) {
616 /* direct distance too far, create
617 * stub entry instead */
618 val
= get_stub(me
, sym
->st_value
, addend
,
619 ELF_STUB_DIRECT
, loc0
, targetsec
);
620 val
= (val
- dot
- 8)/4;
621 CHECK_RELOC(val
, 17);
623 *loc
= (*loc
& ~0x1f1ffd) | reassemble_17(val
);
625 case R_PARISC_PCREL22F
:
626 /* 22-bit PC relative address; only defined for pa20 */
627 /* calculate direct call offset */
629 val
= (val
- dot
- 8)/4;
630 if (!RELOC_REACHABLE(val
, 22)) {
631 /* direct distance too far, create
632 * stub entry instead */
633 val
= get_stub(me
, sym
->st_value
, addend
,
634 ELF_STUB_DIRECT
, loc0
, targetsec
);
635 val
= (val
- dot
- 8)/4;
636 CHECK_RELOC(val
, 22);
638 *loc
= (*loc
& ~0x3ff1ffd) | reassemble_22(val
);
642 printk(KERN_ERR
"module %s: Unknown relocation: %u\n",
643 me
->name
, ELF32_R_TYPE(rel
[i
].r_info
));
652 int apply_relocate_add(Elf_Shdr
*sechdrs
,
654 unsigned int symindex
,
659 Elf64_Rela
*rel
= (void *)sechdrs
[relsec
].sh_addr
;
667 unsigned int targetsec
= sechdrs
[relsec
].sh_info
;
669 DEBUGP("Applying relocate section %u to %u\n", relsec
,
671 for (i
= 0; i
< sechdrs
[relsec
].sh_size
/ sizeof(*rel
); i
++) {
672 /* This is where to make the change */
673 loc
= (void *)sechdrs
[targetsec
].sh_addr
675 /* This is the start of the target section */
676 loc0
= sechdrs
[targetsec
].sh_addr
;
677 /* This is the symbol it is referring to */
678 sym
= (Elf64_Sym
*)sechdrs
[symindex
].sh_addr
679 + ELF64_R_SYM(rel
[i
].r_info
);
680 if (!sym
->st_value
) {
681 printk(KERN_WARNING
"%s: Unknown symbol %s\n",
682 me
->name
, strtab
+ sym
->st_name
);
685 //dot = (sechdrs[relsec].sh_addr + rel->r_offset) & ~0x03;
686 dot
= (Elf64_Addr
)loc
& ~0x03;
687 loc64
= (Elf64_Xword
*)loc
;
690 addend
= rel
[i
].r_addend
;
693 #define r(t) ELF64_R_TYPE(rel[i].r_info)==t ? #t :
694 printk("Symbol %s loc %p val 0x%Lx addend 0x%Lx: %s\n",
695 strtab
+ sym
->st_name
,
707 switch (ELF64_R_TYPE(rel
[i
].r_info
)) {
708 case R_PARISC_LTOFF21L
:
709 /* LT-relative; left 21 bits */
710 val
= get_got(me
, val
, addend
);
711 DEBUGP("LTOFF21L Symbol %s loc %p val %lx\n",
712 strtab
+ sym
->st_name
,
715 *loc
= mask(*loc
, 21) | reassemble_21(val
);
717 case R_PARISC_LTOFF14R
:
718 /* L(ltoff(val+addend)) */
719 /* LT-relative; right 14 bits */
720 val
= get_got(me
, val
, addend
);
722 DEBUGP("LTOFF14R Symbol %s loc %p val %lx\n",
723 strtab
+ sym
->st_name
,
725 *loc
= mask(*loc
, 14) | reassemble_14(val
);
727 case R_PARISC_PCREL22F
:
728 /* PC-relative; 22 bits */
729 DEBUGP("PCREL22F Symbol %s loc %p val %lx\n",
730 strtab
+ sym
->st_name
,
733 /* can we reach it locally? */
734 if (in_local(me
, (void *)val
)) {
735 /* this is the case where the symbol is local
736 * to the module, but in a different section,
737 * so stub the jump in case it's more than 22
739 val
= (val
- dot
- 8)/4;
740 if (!RELOC_REACHABLE(val
, 22)) {
741 /* direct distance too far, create
742 * stub entry instead */
743 val
= get_stub(me
, sym
->st_value
,
744 addend
, ELF_STUB_DIRECT
,
747 /* Ok, we can reach it directly. */
753 if (strncmp(strtab
+ sym
->st_name
, "$$", 2)
755 val
= get_stub(me
, val
, addend
, ELF_STUB_MILLI
,
758 val
= get_stub(me
, val
, addend
, ELF_STUB_GOT
,
761 DEBUGP("STUB FOR %s loc %lx, val %lx+%lx at %lx\n",
762 strtab
+ sym
->st_name
, loc
, sym
->st_value
,
764 val
= (val
- dot
- 8)/4;
765 CHECK_RELOC(val
, 22);
766 *loc
= (*loc
& ~0x3ff1ffd) | reassemble_22(val
);
769 /* 64-bit effective address */
770 *loc64
= val
+ addend
;
772 case R_PARISC_SEGREL32
:
773 /* 32-bit segment relative address */
774 /* See note about special handling of SEGREL32 at
775 * the beginning of this file.
777 *loc
= fsel(val
, addend
);
779 case R_PARISC_FPTR64
:
780 /* 64-bit function address */
781 if(in_local(me
, (void *)(val
+ addend
))) {
782 *loc64
= get_fdesc(me
, val
+addend
);
783 DEBUGP("FDESC for %s at %p points to %lx\n",
784 strtab
+ sym
->st_name
, *loc64
,
785 ((Elf_Fdesc
*)*loc64
)->addr
);
787 /* if the symbol is not local to this
788 * module then val+addend is a pointer
789 * to the function descriptor */
790 DEBUGP("Non local FPTR64 Symbol %s loc %p val %lx\n",
791 strtab
+ sym
->st_name
,
793 *loc64
= val
+ addend
;
798 printk(KERN_ERR
"module %s: Unknown relocation: %Lu\n",
799 me
->name
, ELF64_R_TYPE(rel
[i
].r_info
));
808 register_unwind_table(struct module
*me
,
809 const Elf_Shdr
*sechdrs
)
811 unsigned char *table
, *end
;
814 if (!me
->arch
.unwind_section
)
817 table
= (unsigned char *)sechdrs
[me
->arch
.unwind_section
].sh_addr
;
818 end
= table
+ sechdrs
[me
->arch
.unwind_section
].sh_size
;
819 gp
= (Elf_Addr
)me
->module_core
+ me
->arch
.got_offset
;
821 DEBUGP("register_unwind_table(), sect = %d at 0x%p - 0x%p (gp=0x%lx)\n",
822 me
->arch
.unwind_section
, table
, end
, gp
);
823 me
->arch
.unwind
= unwind_table_add(me
->name
, 0, gp
, table
, end
);
827 deregister_unwind_table(struct module
*me
)
830 unwind_table_remove(me
->arch
.unwind
);
833 int module_finalize(const Elf_Ehdr
*hdr
,
834 const Elf_Shdr
*sechdrs
,
839 const char *strtab
= NULL
;
840 Elf_Sym
*newptr
, *oldptr
;
841 Elf_Shdr
*symhdr
= NULL
;
846 entry
= (Elf_Fdesc
*)me
->init
;
847 printk("FINALIZE, ->init FPTR is %p, GP %lx ADDR %lx\n", entry
,
848 entry
->gp
, entry
->addr
);
849 addr
= (u32
*)entry
->addr
;
850 printk("INSNS: %x %x %x %x\n",
851 addr
[0], addr
[1], addr
[2], addr
[3]);
852 printk("got entries used %ld, gots max %ld\n"
853 "fdescs used %ld, fdescs max %ld\n",
854 me
->arch
.got_count
, me
->arch
.got_max
,
855 me
->arch
.fdesc_count
, me
->arch
.fdesc_max
);
858 register_unwind_table(me
, sechdrs
);
860 /* haven't filled in me->symtab yet, so have to find it
862 for (i
= 1; i
< hdr
->e_shnum
; i
++) {
863 if(sechdrs
[i
].sh_type
== SHT_SYMTAB
864 && (sechdrs
[i
].sh_type
& SHF_ALLOC
)) {
865 int strindex
= sechdrs
[i
].sh_link
;
867 * The cast is to drop the const from
868 * the sechdrs pointer */
869 symhdr
= (Elf_Shdr
*)&sechdrs
[i
];
870 strtab
= (char *)sechdrs
[strindex
].sh_addr
;
875 DEBUGP("module %s: strtab %p, symhdr %p\n",
876 me
->name
, strtab
, symhdr
);
878 if(me
->arch
.got_count
> MAX_GOTS
) {
879 printk(KERN_ERR
"%s: Global Offset Table overflow (used %ld, allowed %d)\n",
880 me
->name
, me
->arch
.got_count
, MAX_GOTS
);
884 kfree(me
->arch
.section
);
885 me
->arch
.section
= NULL
;
887 /* no symbol table */
891 oldptr
= (void *)symhdr
->sh_addr
;
892 newptr
= oldptr
+ 1; /* we start counting at 1 */
893 nsyms
= symhdr
->sh_size
/ sizeof(Elf_Sym
);
894 DEBUGP("OLD num_symtab %lu\n", nsyms
);
896 for (i
= 1; i
< nsyms
; i
++) {
897 oldptr
++; /* note, count starts at 1 so preincrement */
898 if(strncmp(strtab
+ oldptr
->st_name
,
908 nsyms
= newptr
- (Elf_Sym
*)symhdr
->sh_addr
;
909 DEBUGP("NEW num_symtab %lu\n", nsyms
);
910 symhdr
->sh_size
= nsyms
* sizeof(Elf_Sym
);
911 return module_bug_finalize(hdr
, sechdrs
, me
);
914 void module_arch_cleanup(struct module
*mod
)
916 deregister_unwind_table(mod
);
917 module_bug_cleanup(mod
);
921 void *dereference_function_descriptor(void *ptr
)
923 Elf64_Fdesc
*desc
= ptr
;
926 if (!probe_kernel_address(&desc
->addr
, p
))