]>
git.proxmox.com Git - mirror_ubuntu-zesty-kernel.git/blob - arch/arm/kernel/module.c
2 * linux/arch/arm/kernel/module.c
4 * Copyright (C) 2002 Russell King.
5 * Modified for nommu by Hyok S. Choi
7 * This program is free software; you can redistribute it and/or modify
8 * it under the terms of the GNU General Public License version 2 as
9 * published by the Free Software Foundation.
11 * Module allocation method suggested by Andi Kleen.
13 #include <linux/module.h>
14 #include <linux/moduleloader.h>
15 #include <linux/kernel.h>
17 #include <linux/elf.h>
18 #include <linux/vmalloc.h>
20 #include <linux/string.h>
21 #include <linux/gfp.h>
23 #include <asm/pgtable.h>
24 #include <asm/sections.h>
25 #include <asm/smp_plat.h>
26 #include <asm/unwind.h>
27 #include <asm/opcodes.h>
29 #ifdef CONFIG_XIP_KERNEL
31 * The XIP kernel text is mapped in the module area for modules and
32 * some other stuff to work without any indirect relocations.
33 * MODULES_VADDR is redefined here and not in asm/memory.h to avoid
34 * recompiling the whole kernel when CONFIG_XIP_KERNEL is turned on/off.
37 #define MODULES_VADDR (((unsigned long)_exiprom + ~PMD_MASK) & PMD_MASK)
41 void *module_alloc(unsigned long size
)
43 void *p
= __vmalloc_node_range(size
, 1, MODULES_VADDR
, MODULES_END
,
44 GFP_KERNEL
, PAGE_KERNEL_EXEC
, 0, NUMA_NO_NODE
,
45 __builtin_return_address(0));
46 if (!IS_ENABLED(CONFIG_ARM_MODULE_PLTS
) || p
)
48 return __vmalloc_node_range(size
, 1, VMALLOC_START
, VMALLOC_END
,
49 GFP_KERNEL
, PAGE_KERNEL_EXEC
, 0, NUMA_NO_NODE
,
50 __builtin_return_address(0));
55 apply_relocate(Elf32_Shdr
*sechdrs
, const char *strtab
, unsigned int symindex
,
56 unsigned int relindex
, struct module
*module
)
58 Elf32_Shdr
*symsec
= sechdrs
+ symindex
;
59 Elf32_Shdr
*relsec
= sechdrs
+ relindex
;
60 Elf32_Shdr
*dstsec
= sechdrs
+ relsec
->sh_info
;
61 Elf32_Rel
*rel
= (void *)relsec
->sh_addr
;
64 for (i
= 0; i
< relsec
->sh_size
/ sizeof(Elf32_Rel
); i
++, rel
++) {
70 #ifdef CONFIG_THUMB2_KERNEL
71 u32 upper
, lower
, sign
, j1
, j2
;
74 offset
= ELF32_R_SYM(rel
->r_info
);
75 if (offset
< 0 || offset
> (symsec
->sh_size
/ sizeof(Elf32_Sym
))) {
76 pr_err("%s: section %u reloc %u: bad relocation sym offset\n",
77 module
->name
, relindex
, i
);
81 sym
= ((Elf32_Sym
*)symsec
->sh_addr
) + offset
;
82 symname
= strtab
+ sym
->st_name
;
84 if (rel
->r_offset
< 0 || rel
->r_offset
> dstsec
->sh_size
- sizeof(u32
)) {
85 pr_err("%s: section %u reloc %u sym '%s': out of bounds relocation, offset %d size %u\n",
86 module
->name
, relindex
, i
, symname
,
87 rel
->r_offset
, dstsec
->sh_size
);
91 loc
= dstsec
->sh_addr
+ rel
->r_offset
;
93 switch (ELF32_R_TYPE(rel
->r_info
)) {
100 *(u32
*)loc
+= sym
->st_value
;
106 if (sym
->st_value
& 3) {
107 pr_err("%s: section %u reloc %u sym '%s': unsupported interworking call (ARM -> Thumb)\n",
108 module
->name
, relindex
, i
, symname
);
112 offset
= __mem_to_opcode_arm(*(u32
*)loc
);
113 offset
= (offset
& 0x00ffffff) << 2;
114 if (offset
& 0x02000000)
115 offset
-= 0x04000000;
117 offset
+= sym
->st_value
- loc
;
120 * Route through a PLT entry if 'offset' exceeds the
121 * supported range. Note that 'offset + loc + 8'
122 * contains the absolute jump target, i.e.,
123 * @sym + addend, corrected for the +8 PC bias.
125 if (IS_ENABLED(CONFIG_ARM_MODULE_PLTS
) &&
126 (offset
<= (s32
)0xfe000000 ||
127 offset
>= (s32
)0x02000000))
128 offset
= get_module_plt(module
, loc
,
132 if (offset
<= (s32
)0xfe000000 ||
133 offset
>= (s32
)0x02000000) {
134 pr_err("%s: section %u reloc %u sym '%s': relocation %u out of range (%#lx -> %#x)\n",
135 module
->name
, relindex
, i
, symname
,
136 ELF32_R_TYPE(rel
->r_info
), loc
,
142 offset
&= 0x00ffffff;
144 *(u32
*)loc
&= __opcode_to_mem_arm(0xff000000);
145 *(u32
*)loc
|= __opcode_to_mem_arm(offset
);
149 /* Preserve Rm and the condition code. Alter
150 * other bits to re-code instruction as
153 *(u32
*)loc
&= __opcode_to_mem_arm(0xf000000f);
154 *(u32
*)loc
|= __opcode_to_mem_arm(0x01a0f000);
158 offset
= *(u32
*)loc
+ sym
->st_value
- loc
;
159 *(u32
*)loc
= offset
& 0x7fffffff;
162 case R_ARM_MOVW_ABS_NC
:
164 offset
= tmp
= __mem_to_opcode_arm(*(u32
*)loc
);
165 offset
= ((offset
& 0xf0000) >> 4) | (offset
& 0xfff);
166 offset
= (offset
^ 0x8000) - 0x8000;
168 offset
+= sym
->st_value
;
169 if (ELF32_R_TYPE(rel
->r_info
) == R_ARM_MOVT_ABS
)
173 tmp
|= ((offset
& 0xf000) << 4) |
176 *(u32
*)loc
= __opcode_to_mem_arm(tmp
);
179 #ifdef CONFIG_THUMB2_KERNEL
181 case R_ARM_THM_JUMP24
:
183 * For function symbols, only Thumb addresses are
184 * allowed (no interworking).
186 * For non-function symbols, the destination
187 * has no specific ARM/Thumb disposition, so
188 * the branch is resolved under the assumption
189 * that interworking is not required.
191 if (ELF32_ST_TYPE(sym
->st_info
) == STT_FUNC
&&
192 !(sym
->st_value
& 1)) {
193 pr_err("%s: section %u reloc %u sym '%s': unsupported interworking call (Thumb -> ARM)\n",
194 module
->name
, relindex
, i
, symname
);
198 upper
= __mem_to_opcode_thumb16(*(u16
*)loc
);
199 lower
= __mem_to_opcode_thumb16(*(u16
*)(loc
+ 2));
202 * 25 bit signed address range (Thumb-2 BL and B.W
204 * S:I1:I2:imm10:imm11:0
206 * S = upper[10] = offset[24]
207 * I1 = ~(J1 ^ S) = offset[23]
208 * I2 = ~(J2 ^ S) = offset[22]
209 * imm10 = upper[9:0] = offset[21:12]
210 * imm11 = lower[10:0] = offset[11:1]
214 sign
= (upper
>> 10) & 1;
215 j1
= (lower
>> 13) & 1;
216 j2
= (lower
>> 11) & 1;
217 offset
= (sign
<< 24) | ((~(j1
^ sign
) & 1) << 23) |
218 ((~(j2
^ sign
) & 1) << 22) |
219 ((upper
& 0x03ff) << 12) |
220 ((lower
& 0x07ff) << 1);
221 if (offset
& 0x01000000)
222 offset
-= 0x02000000;
223 offset
+= sym
->st_value
- loc
;
226 * Route through a PLT entry if 'offset' exceeds the
229 if (IS_ENABLED(CONFIG_ARM_MODULE_PLTS
) &&
230 (offset
<= (s32
)0xff000000 ||
231 offset
>= (s32
)0x01000000))
232 offset
= get_module_plt(module
, loc
,
236 if (offset
<= (s32
)0xff000000 ||
237 offset
>= (s32
)0x01000000) {
238 pr_err("%s: section %u reloc %u sym '%s': relocation %u out of range (%#lx -> %#x)\n",
239 module
->name
, relindex
, i
, symname
,
240 ELF32_R_TYPE(rel
->r_info
), loc
,
245 sign
= (offset
>> 24) & 1;
246 j1
= sign
^ (~(offset
>> 23) & 1);
247 j2
= sign
^ (~(offset
>> 22) & 1);
248 upper
= (u16
)((upper
& 0xf800) | (sign
<< 10) |
249 ((offset
>> 12) & 0x03ff));
250 lower
= (u16
)((lower
& 0xd000) |
251 (j1
<< 13) | (j2
<< 11) |
252 ((offset
>> 1) & 0x07ff));
254 *(u16
*)loc
= __opcode_to_mem_thumb16(upper
);
255 *(u16
*)(loc
+ 2) = __opcode_to_mem_thumb16(lower
);
258 case R_ARM_THM_MOVW_ABS_NC
:
259 case R_ARM_THM_MOVT_ABS
:
260 upper
= __mem_to_opcode_thumb16(*(u16
*)loc
);
261 lower
= __mem_to_opcode_thumb16(*(u16
*)(loc
+ 2));
264 * MOVT/MOVW instructions encoding in Thumb-2:
268 * imm3 = lower[14:12]
271 * imm16 = imm4:i:imm3:imm8
273 offset
= ((upper
& 0x000f) << 12) |
274 ((upper
& 0x0400) << 1) |
275 ((lower
& 0x7000) >> 4) | (lower
& 0x00ff);
276 offset
= (offset
^ 0x8000) - 0x8000;
277 offset
+= sym
->st_value
;
279 if (ELF32_R_TYPE(rel
->r_info
) == R_ARM_THM_MOVT_ABS
)
282 upper
= (u16
)((upper
& 0xfbf0) |
283 ((offset
& 0xf000) >> 12) |
284 ((offset
& 0x0800) >> 1));
285 lower
= (u16
)((lower
& 0x8f00) |
286 ((offset
& 0x0700) << 4) |
288 *(u16
*)loc
= __opcode_to_mem_thumb16(upper
);
289 *(u16
*)(loc
+ 2) = __opcode_to_mem_thumb16(lower
);
294 pr_err("%s: unknown relocation: %u\n",
295 module
->name
, ELF32_R_TYPE(rel
->r_info
));
302 struct mod_unwind_map
{
303 const Elf_Shdr
*unw_sec
;
304 const Elf_Shdr
*txt_sec
;
307 static const Elf_Shdr
*find_mod_section(const Elf32_Ehdr
*hdr
,
308 const Elf_Shdr
*sechdrs
, const char *name
)
310 const Elf_Shdr
*s
, *se
;
311 const char *secstrs
= (void *)hdr
+ sechdrs
[hdr
->e_shstrndx
].sh_offset
;
313 for (s
= sechdrs
, se
= sechdrs
+ hdr
->e_shnum
; s
< se
; s
++)
314 if (strcmp(name
, secstrs
+ s
->sh_name
) == 0)
320 extern void fixup_pv_table(const void *, unsigned long);
321 extern void fixup_smp(const void *, unsigned long);
323 int module_finalize(const Elf32_Ehdr
*hdr
, const Elf_Shdr
*sechdrs
,
326 const Elf_Shdr
*s
= NULL
;
327 #ifdef CONFIG_ARM_UNWIND
328 const char *secstrs
= (void *)hdr
+ sechdrs
[hdr
->e_shstrndx
].sh_offset
;
329 const Elf_Shdr
*sechdrs_end
= sechdrs
+ hdr
->e_shnum
;
330 struct mod_unwind_map maps
[ARM_SEC_MAX
];
333 memset(maps
, 0, sizeof(maps
));
335 for (s
= sechdrs
; s
< sechdrs_end
; s
++) {
336 const char *secname
= secstrs
+ s
->sh_name
;
338 if (!(s
->sh_flags
& SHF_ALLOC
))
341 if (strcmp(".ARM.exidx.init.text", secname
) == 0)
342 maps
[ARM_SEC_INIT
].unw_sec
= s
;
343 else if (strcmp(".ARM.exidx", secname
) == 0)
344 maps
[ARM_SEC_CORE
].unw_sec
= s
;
345 else if (strcmp(".ARM.exidx.exit.text", secname
) == 0)
346 maps
[ARM_SEC_EXIT
].unw_sec
= s
;
347 else if (strcmp(".ARM.exidx.text.unlikely", secname
) == 0)
348 maps
[ARM_SEC_UNLIKELY
].unw_sec
= s
;
349 else if (strcmp(".ARM.exidx.text.hot", secname
) == 0)
350 maps
[ARM_SEC_HOT
].unw_sec
= s
;
351 else if (strcmp(".init.text", secname
) == 0)
352 maps
[ARM_SEC_INIT
].txt_sec
= s
;
353 else if (strcmp(".text", secname
) == 0)
354 maps
[ARM_SEC_CORE
].txt_sec
= s
;
355 else if (strcmp(".exit.text", secname
) == 0)
356 maps
[ARM_SEC_EXIT
].txt_sec
= s
;
357 else if (strcmp(".text.unlikely", secname
) == 0)
358 maps
[ARM_SEC_UNLIKELY
].txt_sec
= s
;
359 else if (strcmp(".text.hot", secname
) == 0)
360 maps
[ARM_SEC_HOT
].txt_sec
= s
;
363 for (i
= 0; i
< ARM_SEC_MAX
; i
++)
364 if (maps
[i
].unw_sec
&& maps
[i
].txt_sec
)
365 mod
->arch
.unwind
[i
] =
366 unwind_table_add(maps
[i
].unw_sec
->sh_addr
,
367 maps
[i
].unw_sec
->sh_size
,
368 maps
[i
].txt_sec
->sh_addr
,
369 maps
[i
].txt_sec
->sh_size
);
371 #ifdef CONFIG_ARM_PATCH_PHYS_VIRT
372 s
= find_mod_section(hdr
, sechdrs
, ".pv_table");
374 fixup_pv_table((void *)s
->sh_addr
, s
->sh_size
);
376 s
= find_mod_section(hdr
, sechdrs
, ".alt.smp.init");
378 #ifdef CONFIG_SMP_ON_UP
379 fixup_smp((void *)s
->sh_addr
, s
->sh_size
);
387 module_arch_cleanup(struct module
*mod
)
389 #ifdef CONFIG_ARM_UNWIND
392 for (i
= 0; i
< ARM_SEC_MAX
; i
++)
393 if (mod
->arch
.unwind
[i
])
394 unwind_table_del(mod
->arch
.unwind
[i
]);