Commit | Line | Data |
---|---|---|
7d485f64 AB |
1 | /* |
2 | * Copyright (C) 2014 Linaro Ltd. <ard.biesheuvel@linaro.org> | |
3 | * | |
4 | * This program is free software; you can redistribute it and/or modify | |
5 | * it under the terms of the GNU General Public License version 2 as | |
6 | * published by the Free Software Foundation. | |
7 | */ | |
8 | ||
9 | #include <linux/elf.h> | |
10 | #include <linux/kernel.h> | |
11 | #include <linux/module.h> | |
1031a7e6 | 12 | #include <linux/sort.h> |
7d485f64 AB |
13 | |
14 | #include <asm/cache.h> | |
15 | #include <asm/opcodes.h> | |
16 | ||
17 | #define PLT_ENT_STRIDE L1_CACHE_BYTES | |
18 | #define PLT_ENT_COUNT (PLT_ENT_STRIDE / sizeof(u32)) | |
19 | #define PLT_ENT_SIZE (sizeof(struct plt_entries) / PLT_ENT_COUNT) | |
20 | ||
21 | #ifdef CONFIG_THUMB2_KERNEL | |
22 | #define PLT_ENT_LDR __opcode_to_mem_thumb32(0xf8dff000 | \ | |
23 | (PLT_ENT_STRIDE - 4)) | |
24 | #else | |
25 | #define PLT_ENT_LDR __opcode_to_mem_arm(0xe59ff000 | \ | |
26 | (PLT_ENT_STRIDE - 8)) | |
27 | #endif | |
28 | ||
29 | struct plt_entries { | |
30 | u32 ldr[PLT_ENT_COUNT]; | |
31 | u32 lit[PLT_ENT_COUNT]; | |
32 | }; | |
33 | ||
7d485f64 AB |
34 | u32 get_module_plt(struct module *mod, unsigned long loc, Elf32_Addr val) |
35 | { | |
66e94ba3 AB |
36 | struct plt_entries *plt = (struct plt_entries *)mod->arch.plt->sh_addr; |
37 | int idx = 0; | |
38 | ||
39 | /* | |
40 | * Look for an existing entry pointing to 'val'. Given that the | |
41 | * relocations are sorted, this will be the last entry we allocated. | |
42 | * (if one exists). | |
43 | */ | |
44 | if (mod->arch.plt_count > 0) { | |
45 | plt += (mod->arch.plt_count - 1) / PLT_ENT_COUNT; | |
46 | idx = (mod->arch.plt_count - 1) % PLT_ENT_COUNT; | |
47 | ||
48 | if (plt->lit[idx] == val) | |
49 | return (u32)&plt->ldr[idx]; | |
50 | ||
51 | idx = (idx + 1) % PLT_ENT_COUNT; | |
52 | if (!idx) | |
53 | plt++; | |
7d485f64 | 54 | } |
66e94ba3 AB |
55 | |
56 | mod->arch.plt_count++; | |
57 | BUG_ON(mod->arch.plt_count * PLT_ENT_SIZE > mod->arch.plt->sh_size); | |
58 | ||
59 | if (!idx) | |
60 | /* Populate a new set of entries */ | |
61 | *plt = (struct plt_entries){ | |
62 | { [0 ... PLT_ENT_COUNT - 1] = PLT_ENT_LDR, }, | |
63 | { val, } | |
64 | }; | |
65 | else | |
66 | plt->lit[idx] = val; | |
67 | ||
68 | return (u32)&plt->ldr[idx]; | |
7d485f64 AB |
69 | } |
70 | ||
1031a7e6 AB |
71 | #define cmp_3way(a,b) ((a) < (b) ? -1 : (a) > (b)) |
72 | ||
73 | static int cmp_rel(const void *a, const void *b) | |
7d485f64 | 74 | { |
1031a7e6 | 75 | const Elf32_Rel *x = a, *y = b; |
7d485f64 AB |
76 | int i; |
77 | ||
1031a7e6 AB |
78 | /* sort by type and symbol index */ |
79 | i = cmp_3way(ELF32_R_TYPE(x->r_info), ELF32_R_TYPE(y->r_info)); | |
80 | if (i == 0) | |
81 | i = cmp_3way(ELF32_R_SYM(x->r_info), ELF32_R_SYM(y->r_info)); | |
82 | return i; | |
83 | } | |
7d485f64 | 84 | |
1031a7e6 AB |
85 | static bool is_zero_addend_relocation(Elf32_Addr base, const Elf32_Rel *rel) |
86 | { | |
87 | u32 *tval = (u32 *)(base + rel->r_offset); | |
88 | ||
89 | /* | |
90 | * Do a bitwise compare on the raw addend rather than fully decoding | |
91 | * the offset and doing an arithmetic comparison. | |
92 | * Note that a zero-addend jump/call relocation is encoded taking the | |
93 | * PC bias into account, i.e., -8 for ARM and -4 for Thumb2. | |
94 | */ | |
95 | switch (ELF32_R_TYPE(rel->r_info)) { | |
96 | u16 upper, lower; | |
97 | ||
98 | case R_ARM_THM_CALL: | |
99 | case R_ARM_THM_JUMP24: | |
100 | upper = __mem_to_opcode_thumb16(((u16 *)tval)[0]); | |
101 | lower = __mem_to_opcode_thumb16(((u16 *)tval)[1]); | |
102 | ||
103 | return (upper & 0x7ff) == 0x7ff && (lower & 0x2fff) == 0x2ffe; | |
104 | ||
105 | case R_ARM_CALL: | |
106 | case R_ARM_PC24: | |
107 | case R_ARM_JUMP24: | |
108 | return (__mem_to_opcode_arm(*tval) & 0xffffff) == 0xfffffe; | |
7d485f64 | 109 | } |
1031a7e6 AB |
110 | BUG(); |
111 | } | |
112 | ||
113 | static bool duplicate_rel(Elf32_Addr base, const Elf32_Rel *rel, int num) | |
114 | { | |
115 | const Elf32_Rel *prev; | |
116 | ||
117 | /* | |
118 | * Entries are sorted by type and symbol index. That means that, | |
119 | * if a duplicate entry exists, it must be in the preceding | |
120 | * slot. | |
121 | */ | |
122 | if (!num) | |
123 | return false; | |
124 | ||
125 | prev = rel + num - 1; | |
126 | return cmp_rel(rel + num, prev) == 0 && | |
127 | is_zero_addend_relocation(base, prev); | |
7d485f64 AB |
128 | } |
129 | ||
130 | /* Count how many PLT entries we may need */ | |
05123fef AB |
131 | static unsigned int count_plts(const Elf32_Sym *syms, Elf32_Addr base, |
132 | const Elf32_Rel *rel, int num) | |
7d485f64 AB |
133 | { |
134 | unsigned int ret = 0; | |
05123fef | 135 | const Elf32_Sym *s; |
7d485f64 AB |
136 | int i; |
137 | ||
05123fef | 138 | for (i = 0; i < num; i++) { |
7d485f64 AB |
139 | switch (ELF32_R_TYPE(rel[i].r_info)) { |
140 | case R_ARM_CALL: | |
141 | case R_ARM_PC24: | |
142 | case R_ARM_JUMP24: | |
7d485f64 AB |
143 | case R_ARM_THM_CALL: |
144 | case R_ARM_THM_JUMP24: | |
05123fef AB |
145 | /* |
146 | * We only have to consider branch targets that resolve | |
147 | * to undefined symbols. This is not simply a heuristic, | |
148 | * it is a fundamental limitation, since the PLT itself | |
149 | * is part of the module, and needs to be within range | |
150 | * as well, so modules can never grow beyond that limit. | |
151 | */ | |
152 | s = syms + ELF32_R_SYM(rel[i].r_info); | |
153 | if (s->st_shndx != SHN_UNDEF) | |
154 | break; | |
155 | ||
1031a7e6 AB |
156 | /* |
157 | * Jump relocations with non-zero addends against | |
158 | * undefined symbols are supported by the ELF spec, but | |
159 | * do not occur in practice (e.g., 'jump n bytes past | |
160 | * the entry point of undefined function symbol f'). | |
161 | * So we need to support them, but there is no need to | |
162 | * take them into consideration when trying to optimize | |
163 | * this code. So let's only check for duplicates when | |
164 | * the addend is zero. | |
165 | */ | |
166 | if (!is_zero_addend_relocation(base, rel + i) || | |
167 | !duplicate_rel(base, rel, i)) | |
7d485f64 AB |
168 | ret++; |
169 | } | |
05123fef | 170 | } |
7d485f64 AB |
171 | return ret; |
172 | } | |
173 | ||
174 | int module_frob_arch_sections(Elf_Ehdr *ehdr, Elf_Shdr *sechdrs, | |
175 | char *secstrings, struct module *mod) | |
176 | { | |
35fa91ee | 177 | unsigned long plts = 0; |
7d485f64 | 178 | Elf32_Shdr *s, *sechdrs_end = sechdrs + ehdr->e_shnum; |
05123fef | 179 | Elf32_Sym *syms = NULL; |
7d485f64 AB |
180 | |
181 | /* | |
182 | * To store the PLTs, we expand the .text section for core module code | |
35fa91ee | 183 | * and for initialization code. |
7d485f64 | 184 | */ |
05123fef | 185 | for (s = sechdrs; s < sechdrs_end; ++s) { |
35fa91ee AB |
186 | if (strcmp(".plt", secstrings + s->sh_name) == 0) |
187 | mod->arch.plt = s; | |
05123fef AB |
188 | else if (s->sh_type == SHT_SYMTAB) |
189 | syms = (Elf32_Sym *)s->sh_addr; | |
190 | } | |
7d485f64 | 191 | |
35fa91ee AB |
192 | if (!mod->arch.plt) { |
193 | pr_err("%s: module PLT section missing\n", mod->name); | |
7d485f64 AB |
194 | return -ENOEXEC; |
195 | } | |
05123fef AB |
196 | if (!syms) { |
197 | pr_err("%s: module symtab section missing\n", mod->name); | |
198 | return -ENOEXEC; | |
199 | } | |
7d485f64 AB |
200 | |
201 | for (s = sechdrs + 1; s < sechdrs_end; ++s) { | |
1031a7e6 | 202 | Elf32_Rel *rels = (void *)ehdr + s->sh_offset; |
7d485f64 AB |
203 | int numrels = s->sh_size / sizeof(Elf32_Rel); |
204 | Elf32_Shdr *dstsec = sechdrs + s->sh_info; | |
205 | ||
206 | if (s->sh_type != SHT_REL) | |
207 | continue; | |
208 | ||
05123fef AB |
209 | /* ignore relocations that operate on non-exec sections */ |
210 | if (!(dstsec->sh_flags & SHF_EXECINSTR)) | |
211 | continue; | |
212 | ||
1031a7e6 AB |
213 | /* sort by type and symbol index */ |
214 | sort(rels, numrels, sizeof(Elf32_Rel), cmp_rel, NULL); | |
215 | ||
05123fef | 216 | plts += count_plts(syms, dstsec->sh_addr, rels, numrels); |
7d485f64 AB |
217 | } |
218 | ||
35fa91ee AB |
219 | mod->arch.plt->sh_type = SHT_NOBITS; |
220 | mod->arch.plt->sh_flags = SHF_EXECINSTR | SHF_ALLOC; | |
221 | mod->arch.plt->sh_addralign = L1_CACHE_BYTES; | |
222 | mod->arch.plt->sh_size = round_up(plts * PLT_ENT_SIZE, | |
223 | sizeof(struct plt_entries)); | |
224 | mod->arch.plt_count = 0; | |
225 | ||
226 | pr_debug("%s: plt=%x\n", __func__, mod->arch.plt->sh_size); | |
7d485f64 AB |
227 | return 0; |
228 | } |