Linux Audio

Check our new training course

Loading...
v4.17
 
  1/*
  2 *  linux/arch/arm/kernel/module.c
  3 *
  4 *  Copyright (C) 2002 Russell King.
  5 *  Modified for nommu by Hyok S. Choi
  6 *
  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.
 10 *
 11 * Module allocation method suggested by Andi Kleen.
 12 */
 13#include <linux/module.h>
 14#include <linux/moduleloader.h>
 15#include <linux/kernel.h>
 16#include <linux/mm.h>
 17#include <linux/elf.h>
 18#include <linux/vmalloc.h>
 19#include <linux/fs.h>
 20#include <linux/string.h>
 21#include <linux/gfp.h>
 22
 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>
 28
 29#ifdef CONFIG_XIP_KERNEL
 30/*
 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.
 35 */
 36#undef MODULES_VADDR
 37#define MODULES_VADDR	(((unsigned long)_exiprom + ~PMD_MASK) & PMD_MASK)
 38#endif
 39
 40#ifdef CONFIG_MMU
 41void *module_alloc(unsigned long size)
 42{
 43	gfp_t gfp_mask = GFP_KERNEL;
 44	void *p;
 45
 46	/* Silence the initial allocation */
 47	if (IS_ENABLED(CONFIG_ARM_MODULE_PLTS))
 48		gfp_mask |= __GFP_NOWARN;
 49
 50	p = __vmalloc_node_range(size, 1, MODULES_VADDR, MODULES_END,
 51				gfp_mask, PAGE_KERNEL_EXEC, 0, NUMA_NO_NODE,
 52				__builtin_return_address(0));
 53	if (!IS_ENABLED(CONFIG_ARM_MODULE_PLTS) || p)
 54		return p;
 55	return __vmalloc_node_range(size, 1,  VMALLOC_START, VMALLOC_END,
 56				GFP_KERNEL, PAGE_KERNEL_EXEC, 0, NUMA_NO_NODE,
 57				__builtin_return_address(0));
 58}
 59#endif
 60
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 61int
 62apply_relocate(Elf32_Shdr *sechdrs, const char *strtab, unsigned int symindex,
 63	       unsigned int relindex, struct module *module)
 64{
 65	Elf32_Shdr *symsec = sechdrs + symindex;
 66	Elf32_Shdr *relsec = sechdrs + relindex;
 67	Elf32_Shdr *dstsec = sechdrs + relsec->sh_info;
 68	Elf32_Rel *rel = (void *)relsec->sh_addr;
 69	unsigned int i;
 70
 71	for (i = 0; i < relsec->sh_size / sizeof(Elf32_Rel); i++, rel++) {
 72		unsigned long loc;
 73		Elf32_Sym *sym;
 74		const char *symname;
 75		s32 offset;
 76		u32 tmp;
 77#ifdef CONFIG_THUMB2_KERNEL
 78		u32 upper, lower, sign, j1, j2;
 79#endif
 80
 81		offset = ELF32_R_SYM(rel->r_info);
 82		if (offset < 0 || offset > (symsec->sh_size / sizeof(Elf32_Sym))) {
 83			pr_err("%s: section %u reloc %u: bad relocation sym offset\n",
 84				module->name, relindex, i);
 85			return -ENOEXEC;
 86		}
 87
 88		sym = ((Elf32_Sym *)symsec->sh_addr) + offset;
 89		symname = strtab + sym->st_name;
 90
 91		if (rel->r_offset < 0 || rel->r_offset > dstsec->sh_size - sizeof(u32)) {
 92			pr_err("%s: section %u reloc %u sym '%s': out of bounds relocation, offset %d size %u\n",
 93			       module->name, relindex, i, symname,
 94			       rel->r_offset, dstsec->sh_size);
 95			return -ENOEXEC;
 96		}
 97
 98		loc = dstsec->sh_addr + rel->r_offset;
 99
100		switch (ELF32_R_TYPE(rel->r_info)) {
101		case R_ARM_NONE:
102			/* ignore */
103			break;
104
105		case R_ARM_ABS32:
106		case R_ARM_TARGET1:
107			*(u32 *)loc += sym->st_value;
108			break;
109
110		case R_ARM_PC24:
111		case R_ARM_CALL:
112		case R_ARM_JUMP24:
113			if (sym->st_value & 3) {
114				pr_err("%s: section %u reloc %u sym '%s': unsupported interworking call (ARM -> Thumb)\n",
115				       module->name, relindex, i, symname);
116				return -ENOEXEC;
117			}
118
119			offset = __mem_to_opcode_arm(*(u32 *)loc);
120			offset = (offset & 0x00ffffff) << 2;
121			if (offset & 0x02000000)
122				offset -= 0x04000000;
123
124			offset += sym->st_value - loc;
125
126			/*
127			 * Route through a PLT entry if 'offset' exceeds the
128			 * supported range. Note that 'offset + loc + 8'
129			 * contains the absolute jump target, i.e.,
130			 * @sym + addend, corrected for the +8 PC bias.
131			 */
132			if (IS_ENABLED(CONFIG_ARM_MODULE_PLTS) &&
133			    (offset <= (s32)0xfe000000 ||
134			     offset >= (s32)0x02000000))
135				offset = get_module_plt(module, loc,
136							offset + loc + 8)
137					 - loc - 8;
138
139			if (offset <= (s32)0xfe000000 ||
140			    offset >= (s32)0x02000000) {
141				pr_err("%s: section %u reloc %u sym '%s': relocation %u out of range (%#lx -> %#x)\n",
142				       module->name, relindex, i, symname,
143				       ELF32_R_TYPE(rel->r_info), loc,
144				       sym->st_value);
145				return -ENOEXEC;
146			}
147
148			offset >>= 2;
149			offset &= 0x00ffffff;
150
151			*(u32 *)loc &= __opcode_to_mem_arm(0xff000000);
152			*(u32 *)loc |= __opcode_to_mem_arm(offset);
153			break;
154
155	       case R_ARM_V4BX:
156		       /* Preserve Rm and the condition code. Alter
157			* other bits to re-code instruction as
158			* MOV PC,Rm.
159			*/
160		       *(u32 *)loc &= __opcode_to_mem_arm(0xf000000f);
161		       *(u32 *)loc |= __opcode_to_mem_arm(0x01a0f000);
162		       break;
163
164		case R_ARM_PREL31:
165			offset = (*(s32 *)loc << 1) >> 1; /* sign extend */
166			offset += sym->st_value - loc;
167			if (offset >= 0x40000000 || offset < -0x40000000) {
168				pr_err("%s: section %u reloc %u sym '%s': relocation %u out of range (%#lx -> %#x)\n",
169				       module->name, relindex, i, symname,
170				       ELF32_R_TYPE(rel->r_info), loc,
171				       sym->st_value);
172				return -ENOEXEC;
173			}
174			*(u32 *)loc &= 0x80000000;
175			*(u32 *)loc |= offset & 0x7fffffff;
176			break;
177
 
 
 
 
178		case R_ARM_MOVW_ABS_NC:
179		case R_ARM_MOVT_ABS:
 
 
180			offset = tmp = __mem_to_opcode_arm(*(u32 *)loc);
181			offset = ((offset & 0xf0000) >> 4) | (offset & 0xfff);
182			offset = (offset ^ 0x8000) - 0x8000;
183
184			offset += sym->st_value;
185			if (ELF32_R_TYPE(rel->r_info) == R_ARM_MOVT_ABS)
 
 
 
 
186				offset >>= 16;
187
188			tmp &= 0xfff0f000;
189			tmp |= ((offset & 0xf000) << 4) |
190				(offset & 0x0fff);
191
192			*(u32 *)loc = __opcode_to_mem_arm(tmp);
193			break;
194
195#ifdef CONFIG_THUMB2_KERNEL
196		case R_ARM_THM_CALL:
197		case R_ARM_THM_JUMP24:
198			/*
199			 * For function symbols, only Thumb addresses are
200			 * allowed (no interworking).
201			 *
202			 * For non-function symbols, the destination
203			 * has no specific ARM/Thumb disposition, so
204			 * the branch is resolved under the assumption
205			 * that interworking is not required.
206			 */
207			if (ELF32_ST_TYPE(sym->st_info) == STT_FUNC &&
208			    !(sym->st_value & 1)) {
209				pr_err("%s: section %u reloc %u sym '%s': unsupported interworking call (Thumb -> ARM)\n",
210				       module->name, relindex, i, symname);
211				return -ENOEXEC;
212			}
213
214			upper = __mem_to_opcode_thumb16(*(u16 *)loc);
215			lower = __mem_to_opcode_thumb16(*(u16 *)(loc + 2));
216
217			/*
218			 * 25 bit signed address range (Thumb-2 BL and B.W
219			 * instructions):
220			 *   S:I1:I2:imm10:imm11:0
221			 * where:
222			 *   S     = upper[10]   = offset[24]
223			 *   I1    = ~(J1 ^ S)   = offset[23]
224			 *   I2    = ~(J2 ^ S)   = offset[22]
225			 *   imm10 = upper[9:0]  = offset[21:12]
226			 *   imm11 = lower[10:0] = offset[11:1]
227			 *   J1    = lower[13]
228			 *   J2    = lower[11]
229			 */
230			sign = (upper >> 10) & 1;
231			j1 = (lower >> 13) & 1;
232			j2 = (lower >> 11) & 1;
233			offset = (sign << 24) | ((~(j1 ^ sign) & 1) << 23) |
234				((~(j2 ^ sign) & 1) << 22) |
235				((upper & 0x03ff) << 12) |
236				((lower & 0x07ff) << 1);
237			if (offset & 0x01000000)
238				offset -= 0x02000000;
239			offset += sym->st_value - loc;
240
241			/*
242			 * Route through a PLT entry if 'offset' exceeds the
243			 * supported range.
244			 */
245			if (IS_ENABLED(CONFIG_ARM_MODULE_PLTS) &&
246			    (offset <= (s32)0xff000000 ||
247			     offset >= (s32)0x01000000))
248				offset = get_module_plt(module, loc,
249							offset + loc + 4)
250					 - loc - 4;
251
252			if (offset <= (s32)0xff000000 ||
253			    offset >= (s32)0x01000000) {
254				pr_err("%s: section %u reloc %u sym '%s': relocation %u out of range (%#lx -> %#x)\n",
255				       module->name, relindex, i, symname,
256				       ELF32_R_TYPE(rel->r_info), loc,
257				       sym->st_value);
258				return -ENOEXEC;
259			}
260
261			sign = (offset >> 24) & 1;
262			j1 = sign ^ (~(offset >> 23) & 1);
263			j2 = sign ^ (~(offset >> 22) & 1);
264			upper = (u16)((upper & 0xf800) | (sign << 10) |
265					    ((offset >> 12) & 0x03ff));
266			lower = (u16)((lower & 0xd000) |
267				      (j1 << 13) | (j2 << 11) |
268				      ((offset >> 1) & 0x07ff));
269
270			*(u16 *)loc = __opcode_to_mem_thumb16(upper);
271			*(u16 *)(loc + 2) = __opcode_to_mem_thumb16(lower);
272			break;
273
274		case R_ARM_THM_MOVW_ABS_NC:
275		case R_ARM_THM_MOVT_ABS:
 
 
276			upper = __mem_to_opcode_thumb16(*(u16 *)loc);
277			lower = __mem_to_opcode_thumb16(*(u16 *)(loc + 2));
278
279			/*
280			 * MOVT/MOVW instructions encoding in Thumb-2:
281			 *
282			 * i	= upper[10]
283			 * imm4	= upper[3:0]
284			 * imm3	= lower[14:12]
285			 * imm8	= lower[7:0]
286			 *
287			 * imm16 = imm4:i:imm3:imm8
288			 */
289			offset = ((upper & 0x000f) << 12) |
290				((upper & 0x0400) << 1) |
291				((lower & 0x7000) >> 4) | (lower & 0x00ff);
292			offset = (offset ^ 0x8000) - 0x8000;
293			offset += sym->st_value;
294
295			if (ELF32_R_TYPE(rel->r_info) == R_ARM_THM_MOVT_ABS)
 
 
 
 
296				offset >>= 16;
297
298			upper = (u16)((upper & 0xfbf0) |
299				      ((offset & 0xf000) >> 12) |
300				      ((offset & 0x0800) >> 1));
301			lower = (u16)((lower & 0x8f00) |
302				      ((offset & 0x0700) << 4) |
303				      (offset & 0x00ff));
304			*(u16 *)loc = __opcode_to_mem_thumb16(upper);
305			*(u16 *)(loc + 2) = __opcode_to_mem_thumb16(lower);
306			break;
307#endif
308
309		default:
310			pr_err("%s: unknown relocation: %u\n",
311			       module->name, ELF32_R_TYPE(rel->r_info));
312			return -ENOEXEC;
313		}
314	}
315	return 0;
316}
317
318struct mod_unwind_map {
319	const Elf_Shdr *unw_sec;
320	const Elf_Shdr *txt_sec;
321};
322
323static const Elf_Shdr *find_mod_section(const Elf32_Ehdr *hdr,
324	const Elf_Shdr *sechdrs, const char *name)
325{
326	const Elf_Shdr *s, *se;
327	const char *secstrs = (void *)hdr + sechdrs[hdr->e_shstrndx].sh_offset;
328
329	for (s = sechdrs, se = sechdrs + hdr->e_shnum; s < se; s++)
330		if (strcmp(name, secstrs + s->sh_name) == 0)
331			return s;
332
333	return NULL;
334}
335
336extern void fixup_pv_table(const void *, unsigned long);
337extern void fixup_smp(const void *, unsigned long);
338
339int module_finalize(const Elf32_Ehdr *hdr, const Elf_Shdr *sechdrs,
340		    struct module *mod)
341{
342	const Elf_Shdr *s = NULL;
343#ifdef CONFIG_ARM_UNWIND
344	const char *secstrs = (void *)hdr + sechdrs[hdr->e_shstrndx].sh_offset;
345	const Elf_Shdr *sechdrs_end = sechdrs + hdr->e_shnum;
346	struct mod_unwind_map maps[ARM_SEC_MAX];
347	int i;
348
349	memset(maps, 0, sizeof(maps));
350
351	for (s = sechdrs; s < sechdrs_end; s++) {
352		const char *secname = secstrs + s->sh_name;
353
354		if (!(s->sh_flags & SHF_ALLOC))
355			continue;
356
357		if (strcmp(".ARM.exidx.init.text", secname) == 0)
358			maps[ARM_SEC_INIT].unw_sec = s;
359		else if (strcmp(".ARM.exidx", secname) == 0)
360			maps[ARM_SEC_CORE].unw_sec = s;
361		else if (strcmp(".ARM.exidx.exit.text", secname) == 0)
362			maps[ARM_SEC_EXIT].unw_sec = s;
363		else if (strcmp(".ARM.exidx.text.unlikely", secname) == 0)
364			maps[ARM_SEC_UNLIKELY].unw_sec = s;
365		else if (strcmp(".ARM.exidx.text.hot", secname) == 0)
366			maps[ARM_SEC_HOT].unw_sec = s;
367		else if (strcmp(".init.text", secname) == 0)
368			maps[ARM_SEC_INIT].txt_sec = s;
369		else if (strcmp(".text", secname) == 0)
370			maps[ARM_SEC_CORE].txt_sec = s;
371		else if (strcmp(".exit.text", secname) == 0)
372			maps[ARM_SEC_EXIT].txt_sec = s;
373		else if (strcmp(".text.unlikely", secname) == 0)
374			maps[ARM_SEC_UNLIKELY].txt_sec = s;
375		else if (strcmp(".text.hot", secname) == 0)
376			maps[ARM_SEC_HOT].txt_sec = s;
377	}
378
379	for (i = 0; i < ARM_SEC_MAX; i++)
380		if (maps[i].unw_sec && maps[i].txt_sec)
381			mod->arch.unwind[i] =
382				unwind_table_add(maps[i].unw_sec->sh_addr,
383					         maps[i].unw_sec->sh_size,
384					         maps[i].txt_sec->sh_addr,
385					         maps[i].txt_sec->sh_size);
386#endif
387#ifdef CONFIG_ARM_PATCH_PHYS_VIRT
388	s = find_mod_section(hdr, sechdrs, ".pv_table");
389	if (s)
390		fixup_pv_table((void *)s->sh_addr, s->sh_size);
391#endif
392	s = find_mod_section(hdr, sechdrs, ".alt.smp.init");
393	if (s && !is_smp())
394#ifdef CONFIG_SMP_ON_UP
395		fixup_smp((void *)s->sh_addr, s->sh_size);
396#else
397		return -EINVAL;
398#endif
399	return 0;
400}
401
402void
403module_arch_cleanup(struct module *mod)
404{
405#ifdef CONFIG_ARM_UNWIND
406	int i;
407
408	for (i = 0; i < ARM_SEC_MAX; i++)
409		if (mod->arch.unwind[i])
410			unwind_table_del(mod->arch.unwind[i]);
 
 
 
 
 
 
 
 
 
411#endif
412}
v5.14.15
  1// SPDX-License-Identifier: GPL-2.0-only
  2/*
  3 *  linux/arch/arm/kernel/module.c
  4 *
  5 *  Copyright (C) 2002 Russell King.
  6 *  Modified for nommu by Hyok S. Choi
  7 *
 
 
 
 
  8 * Module allocation method suggested by Andi Kleen.
  9 */
 10#include <linux/module.h>
 11#include <linux/moduleloader.h>
 12#include <linux/kernel.h>
 13#include <linux/mm.h>
 14#include <linux/elf.h>
 15#include <linux/vmalloc.h>
 16#include <linux/fs.h>
 17#include <linux/string.h>
 18#include <linux/gfp.h>
 19
 
 20#include <asm/sections.h>
 21#include <asm/smp_plat.h>
 22#include <asm/unwind.h>
 23#include <asm/opcodes.h>
 24
 25#ifdef CONFIG_XIP_KERNEL
 26/*
 27 * The XIP kernel text is mapped in the module area for modules and
 28 * some other stuff to work without any indirect relocations.
 29 * MODULES_VADDR is redefined here and not in asm/memory.h to avoid
 30 * recompiling the whole kernel when CONFIG_XIP_KERNEL is turned on/off.
 31 */
 32#undef MODULES_VADDR
 33#define MODULES_VADDR	(((unsigned long)_exiprom + ~PMD_MASK) & PMD_MASK)
 34#endif
 35
 36#ifdef CONFIG_MMU
 37void *module_alloc(unsigned long size)
 38{
 39	gfp_t gfp_mask = GFP_KERNEL;
 40	void *p;
 41
 42	/* Silence the initial allocation */
 43	if (IS_ENABLED(CONFIG_ARM_MODULE_PLTS))
 44		gfp_mask |= __GFP_NOWARN;
 45
 46	p = __vmalloc_node_range(size, 1, MODULES_VADDR, MODULES_END,
 47				gfp_mask, PAGE_KERNEL_EXEC, 0, NUMA_NO_NODE,
 48				__builtin_return_address(0));
 49	if (!IS_ENABLED(CONFIG_ARM_MODULE_PLTS) || p)
 50		return p;
 51	return __vmalloc_node_range(size, 1,  VMALLOC_START, VMALLOC_END,
 52				GFP_KERNEL, PAGE_KERNEL_EXEC, 0, NUMA_NO_NODE,
 53				__builtin_return_address(0));
 54}
 55#endif
 56
 57bool module_init_section(const char *name)
 58{
 59	return strstarts(name, ".init") ||
 60		strstarts(name, ".ARM.extab.init") ||
 61		strstarts(name, ".ARM.exidx.init");
 62}
 63
 64bool module_exit_section(const char *name)
 65{
 66	return strstarts(name, ".exit") ||
 67		strstarts(name, ".ARM.extab.exit") ||
 68		strstarts(name, ".ARM.exidx.exit");
 69}
 70
 71int
 72apply_relocate(Elf32_Shdr *sechdrs, const char *strtab, unsigned int symindex,
 73	       unsigned int relindex, struct module *module)
 74{
 75	Elf32_Shdr *symsec = sechdrs + symindex;
 76	Elf32_Shdr *relsec = sechdrs + relindex;
 77	Elf32_Shdr *dstsec = sechdrs + relsec->sh_info;
 78	Elf32_Rel *rel = (void *)relsec->sh_addr;
 79	unsigned int i;
 80
 81	for (i = 0; i < relsec->sh_size / sizeof(Elf32_Rel); i++, rel++) {
 82		unsigned long loc;
 83		Elf32_Sym *sym;
 84		const char *symname;
 85		s32 offset;
 86		u32 tmp;
 87#ifdef CONFIG_THUMB2_KERNEL
 88		u32 upper, lower, sign, j1, j2;
 89#endif
 90
 91		offset = ELF32_R_SYM(rel->r_info);
 92		if (offset < 0 || offset > (symsec->sh_size / sizeof(Elf32_Sym))) {
 93			pr_err("%s: section %u reloc %u: bad relocation sym offset\n",
 94				module->name, relindex, i);
 95			return -ENOEXEC;
 96		}
 97
 98		sym = ((Elf32_Sym *)symsec->sh_addr) + offset;
 99		symname = strtab + sym->st_name;
100
101		if (rel->r_offset < 0 || rel->r_offset > dstsec->sh_size - sizeof(u32)) {
102			pr_err("%s: section %u reloc %u sym '%s': out of bounds relocation, offset %d size %u\n",
103			       module->name, relindex, i, symname,
104			       rel->r_offset, dstsec->sh_size);
105			return -ENOEXEC;
106		}
107
108		loc = dstsec->sh_addr + rel->r_offset;
109
110		switch (ELF32_R_TYPE(rel->r_info)) {
111		case R_ARM_NONE:
112			/* ignore */
113			break;
114
115		case R_ARM_ABS32:
116		case R_ARM_TARGET1:
117			*(u32 *)loc += sym->st_value;
118			break;
119
120		case R_ARM_PC24:
121		case R_ARM_CALL:
122		case R_ARM_JUMP24:
123			if (sym->st_value & 3) {
124				pr_err("%s: section %u reloc %u sym '%s': unsupported interworking call (ARM -> Thumb)\n",
125				       module->name, relindex, i, symname);
126				return -ENOEXEC;
127			}
128
129			offset = __mem_to_opcode_arm(*(u32 *)loc);
130			offset = (offset & 0x00ffffff) << 2;
131			if (offset & 0x02000000)
132				offset -= 0x04000000;
133
134			offset += sym->st_value - loc;
135
136			/*
137			 * Route through a PLT entry if 'offset' exceeds the
138			 * supported range. Note that 'offset + loc + 8'
139			 * contains the absolute jump target, i.e.,
140			 * @sym + addend, corrected for the +8 PC bias.
141			 */
142			if (IS_ENABLED(CONFIG_ARM_MODULE_PLTS) &&
143			    (offset <= (s32)0xfe000000 ||
144			     offset >= (s32)0x02000000))
145				offset = get_module_plt(module, loc,
146							offset + loc + 8)
147					 - loc - 8;
148
149			if (offset <= (s32)0xfe000000 ||
150			    offset >= (s32)0x02000000) {
151				pr_err("%s: section %u reloc %u sym '%s': relocation %u out of range (%#lx -> %#x)\n",
152				       module->name, relindex, i, symname,
153				       ELF32_R_TYPE(rel->r_info), loc,
154				       sym->st_value);
155				return -ENOEXEC;
156			}
157
158			offset >>= 2;
159			offset &= 0x00ffffff;
160
161			*(u32 *)loc &= __opcode_to_mem_arm(0xff000000);
162			*(u32 *)loc |= __opcode_to_mem_arm(offset);
163			break;
164
165	       case R_ARM_V4BX:
166		       /* Preserve Rm and the condition code. Alter
167			* other bits to re-code instruction as
168			* MOV PC,Rm.
169			*/
170		       *(u32 *)loc &= __opcode_to_mem_arm(0xf000000f);
171		       *(u32 *)loc |= __opcode_to_mem_arm(0x01a0f000);
172		       break;
173
174		case R_ARM_PREL31:
175			offset = (*(s32 *)loc << 1) >> 1; /* sign extend */
176			offset += sym->st_value - loc;
177			if (offset >= 0x40000000 || offset < -0x40000000) {
178				pr_err("%s: section %u reloc %u sym '%s': relocation %u out of range (%#lx -> %#x)\n",
179				       module->name, relindex, i, symname,
180				       ELF32_R_TYPE(rel->r_info), loc,
181				       sym->st_value);
182				return -ENOEXEC;
183			}
184			*(u32 *)loc &= 0x80000000;
185			*(u32 *)loc |= offset & 0x7fffffff;
186			break;
187
188		case R_ARM_REL32:
189			*(u32 *)loc += sym->st_value - loc;
190			break;
191
192		case R_ARM_MOVW_ABS_NC:
193		case R_ARM_MOVT_ABS:
194		case R_ARM_MOVW_PREL_NC:
195		case R_ARM_MOVT_PREL:
196			offset = tmp = __mem_to_opcode_arm(*(u32 *)loc);
197			offset = ((offset & 0xf0000) >> 4) | (offset & 0xfff);
198			offset = (offset ^ 0x8000) - 0x8000;
199
200			offset += sym->st_value;
201			if (ELF32_R_TYPE(rel->r_info) == R_ARM_MOVT_PREL ||
202			    ELF32_R_TYPE(rel->r_info) == R_ARM_MOVW_PREL_NC)
203				offset -= loc;
204			if (ELF32_R_TYPE(rel->r_info) == R_ARM_MOVT_ABS ||
205			    ELF32_R_TYPE(rel->r_info) == R_ARM_MOVT_PREL)
206				offset >>= 16;
207
208			tmp &= 0xfff0f000;
209			tmp |= ((offset & 0xf000) << 4) |
210				(offset & 0x0fff);
211
212			*(u32 *)loc = __opcode_to_mem_arm(tmp);
213			break;
214
215#ifdef CONFIG_THUMB2_KERNEL
216		case R_ARM_THM_CALL:
217		case R_ARM_THM_JUMP24:
218			/*
219			 * For function symbols, only Thumb addresses are
220			 * allowed (no interworking).
221			 *
222			 * For non-function symbols, the destination
223			 * has no specific ARM/Thumb disposition, so
224			 * the branch is resolved under the assumption
225			 * that interworking is not required.
226			 */
227			if (ELF32_ST_TYPE(sym->st_info) == STT_FUNC &&
228			    !(sym->st_value & 1)) {
229				pr_err("%s: section %u reloc %u sym '%s': unsupported interworking call (Thumb -> ARM)\n",
230				       module->name, relindex, i, symname);
231				return -ENOEXEC;
232			}
233
234			upper = __mem_to_opcode_thumb16(*(u16 *)loc);
235			lower = __mem_to_opcode_thumb16(*(u16 *)(loc + 2));
236
237			/*
238			 * 25 bit signed address range (Thumb-2 BL and B.W
239			 * instructions):
240			 *   S:I1:I2:imm10:imm11:0
241			 * where:
242			 *   S     = upper[10]   = offset[24]
243			 *   I1    = ~(J1 ^ S)   = offset[23]
244			 *   I2    = ~(J2 ^ S)   = offset[22]
245			 *   imm10 = upper[9:0]  = offset[21:12]
246			 *   imm11 = lower[10:0] = offset[11:1]
247			 *   J1    = lower[13]
248			 *   J2    = lower[11]
249			 */
250			sign = (upper >> 10) & 1;
251			j1 = (lower >> 13) & 1;
252			j2 = (lower >> 11) & 1;
253			offset = (sign << 24) | ((~(j1 ^ sign) & 1) << 23) |
254				((~(j2 ^ sign) & 1) << 22) |
255				((upper & 0x03ff) << 12) |
256				((lower & 0x07ff) << 1);
257			if (offset & 0x01000000)
258				offset -= 0x02000000;
259			offset += sym->st_value - loc;
260
261			/*
262			 * Route through a PLT entry if 'offset' exceeds the
263			 * supported range.
264			 */
265			if (IS_ENABLED(CONFIG_ARM_MODULE_PLTS) &&
266			    (offset <= (s32)0xff000000 ||
267			     offset >= (s32)0x01000000))
268				offset = get_module_plt(module, loc,
269							offset + loc + 4)
270					 - loc - 4;
271
272			if (offset <= (s32)0xff000000 ||
273			    offset >= (s32)0x01000000) {
274				pr_err("%s: section %u reloc %u sym '%s': relocation %u out of range (%#lx -> %#x)\n",
275				       module->name, relindex, i, symname,
276				       ELF32_R_TYPE(rel->r_info), loc,
277				       sym->st_value);
278				return -ENOEXEC;
279			}
280
281			sign = (offset >> 24) & 1;
282			j1 = sign ^ (~(offset >> 23) & 1);
283			j2 = sign ^ (~(offset >> 22) & 1);
284			upper = (u16)((upper & 0xf800) | (sign << 10) |
285					    ((offset >> 12) & 0x03ff));
286			lower = (u16)((lower & 0xd000) |
287				      (j1 << 13) | (j2 << 11) |
288				      ((offset >> 1) & 0x07ff));
289
290			*(u16 *)loc = __opcode_to_mem_thumb16(upper);
291			*(u16 *)(loc + 2) = __opcode_to_mem_thumb16(lower);
292			break;
293
294		case R_ARM_THM_MOVW_ABS_NC:
295		case R_ARM_THM_MOVT_ABS:
296		case R_ARM_THM_MOVW_PREL_NC:
297		case R_ARM_THM_MOVT_PREL:
298			upper = __mem_to_opcode_thumb16(*(u16 *)loc);
299			lower = __mem_to_opcode_thumb16(*(u16 *)(loc + 2));
300
301			/*
302			 * MOVT/MOVW instructions encoding in Thumb-2:
303			 *
304			 * i	= upper[10]
305			 * imm4	= upper[3:0]
306			 * imm3	= lower[14:12]
307			 * imm8	= lower[7:0]
308			 *
309			 * imm16 = imm4:i:imm3:imm8
310			 */
311			offset = ((upper & 0x000f) << 12) |
312				((upper & 0x0400) << 1) |
313				((lower & 0x7000) >> 4) | (lower & 0x00ff);
314			offset = (offset ^ 0x8000) - 0x8000;
315			offset += sym->st_value;
316
317			if (ELF32_R_TYPE(rel->r_info) == R_ARM_THM_MOVT_PREL ||
318			    ELF32_R_TYPE(rel->r_info) == R_ARM_THM_MOVW_PREL_NC)
319				offset -= loc;
320			if (ELF32_R_TYPE(rel->r_info) == R_ARM_THM_MOVT_ABS ||
321			    ELF32_R_TYPE(rel->r_info) == R_ARM_THM_MOVT_PREL)
322				offset >>= 16;
323
324			upper = (u16)((upper & 0xfbf0) |
325				      ((offset & 0xf000) >> 12) |
326				      ((offset & 0x0800) >> 1));
327			lower = (u16)((lower & 0x8f00) |
328				      ((offset & 0x0700) << 4) |
329				      (offset & 0x00ff));
330			*(u16 *)loc = __opcode_to_mem_thumb16(upper);
331			*(u16 *)(loc + 2) = __opcode_to_mem_thumb16(lower);
332			break;
333#endif
334
335		default:
336			pr_err("%s: unknown relocation: %u\n",
337			       module->name, ELF32_R_TYPE(rel->r_info));
338			return -ENOEXEC;
339		}
340	}
341	return 0;
342}
343
344struct mod_unwind_map {
345	const Elf_Shdr *unw_sec;
346	const Elf_Shdr *txt_sec;
347};
348
349static const Elf_Shdr *find_mod_section(const Elf32_Ehdr *hdr,
350	const Elf_Shdr *sechdrs, const char *name)
351{
352	const Elf_Shdr *s, *se;
353	const char *secstrs = (void *)hdr + sechdrs[hdr->e_shstrndx].sh_offset;
354
355	for (s = sechdrs, se = sechdrs + hdr->e_shnum; s < se; s++)
356		if (strcmp(name, secstrs + s->sh_name) == 0)
357			return s;
358
359	return NULL;
360}
361
362extern void fixup_pv_table(const void *, unsigned long);
363extern void fixup_smp(const void *, unsigned long);
364
365int module_finalize(const Elf32_Ehdr *hdr, const Elf_Shdr *sechdrs,
366		    struct module *mod)
367{
368	const Elf_Shdr *s = NULL;
369#ifdef CONFIG_ARM_UNWIND
370	const char *secstrs = (void *)hdr + sechdrs[hdr->e_shstrndx].sh_offset;
371	const Elf_Shdr *sechdrs_end = sechdrs + hdr->e_shnum;
372	struct mod_unwind_map maps[ARM_SEC_MAX];
373	int i;
374
375	memset(maps, 0, sizeof(maps));
376
377	for (s = sechdrs; s < sechdrs_end; s++) {
378		const char *secname = secstrs + s->sh_name;
379
380		if (!(s->sh_flags & SHF_ALLOC))
381			continue;
382
383		if (strcmp(".ARM.exidx.init.text", secname) == 0)
384			maps[ARM_SEC_INIT].unw_sec = s;
385		else if (strcmp(".ARM.exidx", secname) == 0)
386			maps[ARM_SEC_CORE].unw_sec = s;
387		else if (strcmp(".ARM.exidx.exit.text", secname) == 0)
388			maps[ARM_SEC_EXIT].unw_sec = s;
389		else if (strcmp(".ARM.exidx.text.unlikely", secname) == 0)
390			maps[ARM_SEC_UNLIKELY].unw_sec = s;
391		else if (strcmp(".ARM.exidx.text.hot", secname) == 0)
392			maps[ARM_SEC_HOT].unw_sec = s;
393		else if (strcmp(".init.text", secname) == 0)
394			maps[ARM_SEC_INIT].txt_sec = s;
395		else if (strcmp(".text", secname) == 0)
396			maps[ARM_SEC_CORE].txt_sec = s;
397		else if (strcmp(".exit.text", secname) == 0)
398			maps[ARM_SEC_EXIT].txt_sec = s;
399		else if (strcmp(".text.unlikely", secname) == 0)
400			maps[ARM_SEC_UNLIKELY].txt_sec = s;
401		else if (strcmp(".text.hot", secname) == 0)
402			maps[ARM_SEC_HOT].txt_sec = s;
403	}
404
405	for (i = 0; i < ARM_SEC_MAX; i++)
406		if (maps[i].unw_sec && maps[i].txt_sec)
407			mod->arch.unwind[i] =
408				unwind_table_add(maps[i].unw_sec->sh_addr,
409					         maps[i].unw_sec->sh_size,
410					         maps[i].txt_sec->sh_addr,
411					         maps[i].txt_sec->sh_size);
412#endif
413#ifdef CONFIG_ARM_PATCH_PHYS_VIRT
414	s = find_mod_section(hdr, sechdrs, ".pv_table");
415	if (s)
416		fixup_pv_table((void *)s->sh_addr, s->sh_size);
417#endif
418	s = find_mod_section(hdr, sechdrs, ".alt.smp.init");
419	if (s && !is_smp())
420#ifdef CONFIG_SMP_ON_UP
421		fixup_smp((void *)s->sh_addr, s->sh_size);
422#else
423		return -EINVAL;
424#endif
425	return 0;
426}
427
428void
429module_arch_cleanup(struct module *mod)
430{
431#ifdef CONFIG_ARM_UNWIND
432	int i;
433
434	for (i = 0; i < ARM_SEC_MAX; i++) {
435		unwind_table_del(mod->arch.unwind[i]);
436		mod->arch.unwind[i] = NULL;
437	}
438#endif
439}
440
441void __weak module_arch_freeing_init(struct module *mod)
442{
443#ifdef CONFIG_ARM_UNWIND
444	unwind_table_del(mod->arch.unwind[ARM_SEC_INIT]);
445	mod->arch.unwind[ARM_SEC_INIT] = NULL;
446#endif
447}