1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21#undef DEBUG
22
23#include <linux/moduleloader.h>
24#include <linux/elf.h>
25#include <linux/mm.h>
26#include <linux/vmalloc.h>
27#include <linux/slab.h>
28#include <linux/fs.h>
29#include <linux/string.h>
30#include <linux/kernel.h>
31#include <linux/spinlock.h>
32#include <linux/jump_label.h>
33
34#include <asm/pgtable.h>
35
36struct mips_hi16 {
37 struct mips_hi16 *next;
38 Elf_Addr *addr;
39 Elf_Addr value;
40};
41
42static LIST_HEAD(dbe_list);
43static DEFINE_SPINLOCK(dbe_lock);
44
45#ifdef MODULE_START
46void *module_alloc(unsigned long size)
47{
48 return __vmalloc_node_range(size, 1, MODULE_START, MODULE_END,
49 GFP_KERNEL, PAGE_KERNEL, -1,
50 __builtin_return_address(0));
51}
52#endif
53
54int apply_r_mips_none(struct module *me, u32 *location, Elf_Addr v)
55{
56 return 0;
57}
58
59static int apply_r_mips_32_rel(struct module *me, u32 *location, Elf_Addr v)
60{
61 *location += v;
62
63 return 0;
64}
65
66static int apply_r_mips_26_rel(struct module *me, u32 *location, Elf_Addr v)
67{
68 if (v % 4) {
69 pr_err("module %s: dangerous R_MIPS_26 REL relocation\n",
70 me->name);
71 return -ENOEXEC;
72 }
73
74 if ((v & 0xf0000000) != (((unsigned long)location + 4) & 0xf0000000)) {
75 printk(KERN_ERR
76 "module %s: relocation overflow\n",
77 me->name);
78 return -ENOEXEC;
79 }
80
81 *location = (*location & ~0x03ffffff) |
82 ((*location + (v >> 2)) & 0x03ffffff);
83
84 return 0;
85}
86
87static int apply_r_mips_hi16_rel(struct module *me, u32 *location, Elf_Addr v)
88{
89 struct mips_hi16 *n;
90
91
92
93
94
95
96 n = kmalloc(sizeof *n, GFP_KERNEL);
97 if (!n)
98 return -ENOMEM;
99
100 n->addr = (Elf_Addr *)location;
101 n->value = v;
102 n->next = me->arch.r_mips_hi16_list;
103 me->arch.r_mips_hi16_list = n;
104
105 return 0;
106}
107
108static void free_relocation_chain(struct mips_hi16 *l)
109{
110 struct mips_hi16 *next;
111
112 while (l) {
113 next = l->next;
114 kfree(l);
115 l = next;
116 }
117}
118
119static int apply_r_mips_lo16_rel(struct module *me, u32 *location, Elf_Addr v)
120{
121 unsigned long insnlo = *location;
122 struct mips_hi16 *l;
123 Elf_Addr val, vallo;
124
125
126 vallo = ((insnlo & 0xffff) ^ 0x8000) - 0x8000;
127
128 if (me->arch.r_mips_hi16_list != NULL) {
129 l = me->arch.r_mips_hi16_list;
130 while (l != NULL) {
131 struct mips_hi16 *next;
132 unsigned long insn;
133
134
135
136
137 if (v != l->value)
138 goto out_danger;
139
140
141
142
143
144
145
146 insn = *l->addr;
147 val = ((insn & 0xffff) << 16) + vallo;
148 val += v;
149
150
151
152
153
154 val = ((val >> 16) + ((val & 0x8000) != 0)) & 0xffff;
155
156 insn = (insn & ~0xffff) | val;
157 *l->addr = insn;
158
159 next = l->next;
160 kfree(l);
161 l = next;
162 }
163
164 me->arch.r_mips_hi16_list = NULL;
165 }
166
167
168
169
170 val = v + vallo;
171 insnlo = (insnlo & ~0xffff) | (val & 0xffff);
172 *location = insnlo;
173
174 return 0;
175
176out_danger:
177 free_relocation_chain(l);
178 me->arch.r_mips_hi16_list = NULL;
179
180 pr_err("module %s: dangerous R_MIPS_LO16 REL relocation\n", me->name);
181
182 return -ENOEXEC;
183}
184
185static int (*reloc_handlers_rel[]) (struct module *me, u32 *location,
186 Elf_Addr v) = {
187 [R_MIPS_NONE] = apply_r_mips_none,
188 [R_MIPS_32] = apply_r_mips_32_rel,
189 [R_MIPS_26] = apply_r_mips_26_rel,
190 [R_MIPS_HI16] = apply_r_mips_hi16_rel,
191 [R_MIPS_LO16] = apply_r_mips_lo16_rel
192};
193
194int apply_relocate(Elf_Shdr *sechdrs, const char *strtab,
195 unsigned int symindex, unsigned int relsec,
196 struct module *me)
197{
198 Elf_Mips_Rel *rel = (void *) sechdrs[relsec].sh_addr;
199 Elf_Sym *sym;
200 u32 *location;
201 unsigned int i;
202 Elf_Addr v;
203 int res;
204
205 pr_debug("Applying relocate section %u to %u\n", relsec,
206 sechdrs[relsec].sh_info);
207
208 me->arch.r_mips_hi16_list = NULL;
209 for (i = 0; i < sechdrs[relsec].sh_size / sizeof(*rel); i++) {
210
211 location = (void *)sechdrs[sechdrs[relsec].sh_info].sh_addr
212 + rel[i].r_offset;
213
214 sym = (Elf_Sym *)sechdrs[symindex].sh_addr
215 + ELF_MIPS_R_SYM(rel[i]);
216 if (IS_ERR_VALUE(sym->st_value)) {
217
218 if (ELF_ST_BIND(sym->st_info) == STB_WEAK)
219 continue;
220 printk(KERN_WARNING "%s: Unknown symbol %s\n",
221 me->name, strtab + sym->st_name);
222 return -ENOENT;
223 }
224
225 v = sym->st_value;
226
227 res = reloc_handlers_rel[ELF_MIPS_R_TYPE(rel[i])](me, location, v);
228 if (res)
229 return res;
230 }
231
232
233
234
235
236
237
238 if (me->arch.r_mips_hi16_list) {
239 free_relocation_chain(me->arch.r_mips_hi16_list);
240 me->arch.r_mips_hi16_list = NULL;
241
242 return -ENOEXEC;
243 }
244
245 return 0;
246}
247
248
249const struct exception_table_entry *search_module_dbetables(unsigned long addr)
250{
251 unsigned long flags;
252 const struct exception_table_entry *e = NULL;
253 struct mod_arch_specific *dbe;
254
255 spin_lock_irqsave(&dbe_lock, flags);
256 list_for_each_entry(dbe, &dbe_list, dbe_list) {
257 e = search_extable(dbe->dbe_start, dbe->dbe_end - 1, addr);
258 if (e)
259 break;
260 }
261 spin_unlock_irqrestore(&dbe_lock, flags);
262
263
264
265 return e;
266}
267
268
269int module_finalize(const Elf_Ehdr *hdr,
270 const Elf_Shdr *sechdrs,
271 struct module *me)
272{
273 const Elf_Shdr *s;
274 char *secstrings = (void *)hdr + sechdrs[hdr->e_shstrndx].sh_offset;
275
276
277 jump_label_apply_nops(me);
278
279 INIT_LIST_HEAD(&me->arch.dbe_list);
280 for (s = sechdrs; s < sechdrs + hdr->e_shnum; s++) {
281 if (strcmp("__dbe_table", secstrings + s->sh_name) != 0)
282 continue;
283 me->arch.dbe_start = (void *)s->sh_addr;
284 me->arch.dbe_end = (void *)s->sh_addr + s->sh_size;
285 spin_lock_irq(&dbe_lock);
286 list_add(&me->arch.dbe_list, &dbe_list);
287 spin_unlock_irq(&dbe_lock);
288 }
289 return 0;
290}
291
292void module_arch_cleanup(struct module *mod)
293{
294 spin_lock_irq(&dbe_lock);
295 list_del(&mod->arch.dbe_list);
296 spin_unlock_irq(&dbe_lock);
297}
298