OpenWrt – Blame information for rev 1
?pathlinks?
Rev | Author | Line No. | Line |
---|---|---|---|
1 | office | 1 | --- a/arch/mips/Makefile |
2 | +++ b/arch/mips/Makefile |
||
3 | @@ -90,8 +90,13 @@ all-$(CONFIG_SYS_SUPPORTS_ZBOOT)+= vmlin |
||
4 | cflags-y += -G 0 -mno-abicalls -fno-pic -pipe -mno-branch-likely |
||
5 | cflags-y += -msoft-float |
||
6 | LDFLAGS_vmlinux += -G 0 -static -n -nostdlib --gc-sections |
||
7 | +ifdef CONFIG_64BIT |
||
8 | KBUILD_AFLAGS_MODULE += -mlong-calls |
||
9 | KBUILD_CFLAGS_MODULE += -mlong-calls |
||
10 | +else |
||
11 | +KBUILD_AFLAGS_MODULE += -mno-long-calls |
||
12 | +KBUILD_CFLAGS_MODULE += -mno-long-calls |
||
13 | +endif |
||
14 | |||
15 | ifndef CONFIG_FUNCTION_TRACER |
||
16 | KBUILD_CFLAGS_KERNEL += -ffunction-sections -fdata-sections |
||
17 | --- a/arch/mips/include/asm/module.h |
||
18 | +++ b/arch/mips/include/asm/module.h |
||
19 | @@ -11,6 +11,11 @@ struct mod_arch_specific { |
||
20 | const struct exception_table_entry *dbe_start; |
||
21 | const struct exception_table_entry *dbe_end; |
||
22 | struct mips_hi16 *r_mips_hi16_list; |
||
23 | + |
||
24 | + void *phys_plt_tbl; |
||
25 | + void *virt_plt_tbl; |
||
26 | + unsigned int phys_plt_offset; |
||
27 | + unsigned int virt_plt_offset; |
||
28 | }; |
||
29 | |||
30 | typedef uint8_t Elf64_Byte; /* Type for a 8-bit quantity. */ |
||
31 | --- a/arch/mips/kernel/module.c |
||
32 | +++ b/arch/mips/kernel/module.c |
||
33 | @@ -43,14 +43,222 @@ struct mips_hi16 { |
||
34 | static LIST_HEAD(dbe_list); |
||
35 | static DEFINE_SPINLOCK(dbe_lock); |
||
36 | |||
37 | -#ifdef MODULE_START |
||
38 | +/* |
||
39 | + * Get the potential max trampolines size required of the init and |
||
40 | + * non-init sections. Only used if we cannot find enough contiguous |
||
41 | + * physically mapped memory to put the module into. |
||
42 | + */ |
||
43 | +static unsigned int |
||
44 | +get_plt_size(const Elf_Ehdr *hdr, const Elf_Shdr *sechdrs, |
||
45 | + const char *secstrings, unsigned int symindex, bool is_init) |
||
46 | +{ |
||
47 | + unsigned long ret = 0; |
||
48 | + unsigned int i, j; |
||
49 | + Elf_Sym *syms; |
||
50 | + |
||
51 | + /* Everything marked ALLOC (this includes the exported symbols) */ |
||
52 | + for (i = 1; i < hdr->e_shnum; ++i) { |
||
53 | + unsigned int info = sechdrs[i].sh_info; |
||
54 | + |
||
55 | + if (sechdrs[i].sh_type != SHT_REL |
||
56 | + && sechdrs[i].sh_type != SHT_RELA) |
||
57 | + continue; |
||
58 | + |
||
59 | + /* Not a valid relocation section? */ |
||
60 | + if (info >= hdr->e_shnum) |
||
61 | + continue; |
||
62 | + |
||
63 | + /* Don't bother with non-allocated sections */ |
||
64 | + if (!(sechdrs[info].sh_flags & SHF_ALLOC)) |
||
65 | + continue; |
||
66 | + |
||
67 | + /* If it's called *.init*, and we're not init, we're |
||
68 | + not interested */ |
||
69 | + if ((strstr(secstrings + sechdrs[i].sh_name, ".init") != 0) |
||
70 | + != is_init) |
||
71 | + continue; |
||
72 | + |
||
73 | + syms = (Elf_Sym *) sechdrs[symindex].sh_addr; |
||
74 | + if (sechdrs[i].sh_type == SHT_REL) { |
||
75 | + Elf_Mips_Rel *rel = (void *) sechdrs[i].sh_addr; |
||
76 | + unsigned int size = sechdrs[i].sh_size / sizeof(*rel); |
||
77 | + |
||
78 | + for (j = 0; j < size; ++j) { |
||
79 | + Elf_Sym *sym; |
||
80 | + |
||
81 | + if (ELF_MIPS_R_TYPE(rel[j]) != R_MIPS_26) |
||
82 | + continue; |
||
83 | + |
||
84 | + sym = syms + ELF_MIPS_R_SYM(rel[j]); |
||
85 | + if (!is_init && sym->st_shndx != SHN_UNDEF) |
||
86 | + continue; |
||
87 | + |
||
88 | + ret += 4 * sizeof(int); |
||
89 | + } |
||
90 | + } else { |
||
91 | + Elf_Mips_Rela *rela = (void *) sechdrs[i].sh_addr; |
||
92 | + unsigned int size = sechdrs[i].sh_size / sizeof(*rela); |
||
93 | + |
||
94 | + for (j = 0; j < size; ++j) { |
||
95 | + Elf_Sym *sym; |
||
96 | + |
||
97 | + if (ELF_MIPS_R_TYPE(rela[j]) != R_MIPS_26) |
||
98 | + continue; |
||
99 | + |
||
100 | + sym = syms + ELF_MIPS_R_SYM(rela[j]); |
||
101 | + if (!is_init && sym->st_shndx != SHN_UNDEF) |
||
102 | + continue; |
||
103 | + |
||
104 | + ret += 4 * sizeof(int); |
||
105 | + } |
||
106 | + } |
||
107 | + } |
||
108 | + |
||
109 | + return ret; |
||
110 | +} |
||
111 | + |
||
112 | +#ifndef MODULE_START |
||
113 | +static void *alloc_phys(unsigned long size) |
||
114 | +{ |
||
115 | + unsigned order; |
||
116 | + struct page *page; |
||
117 | + struct page *p; |
||
118 | + |
||
119 | + size = PAGE_ALIGN(size); |
||
120 | + order = get_order(size); |
||
121 | + |
||
122 | + page = alloc_pages(GFP_KERNEL | __GFP_NORETRY | __GFP_NOWARN | |
||
123 | + __GFP_THISNODE, order); |
||
124 | + if (!page) |
||
125 | + return NULL; |
||
126 | + |
||
127 | + split_page(page, order); |
||
128 | + |
||
129 | + for (p = page + (size >> PAGE_SHIFT); p < page + (1 << order); ++p) |
||
130 | + __free_page(p); |
||
131 | + |
||
132 | + return page_address(page); |
||
133 | +} |
||
134 | +#endif |
||
135 | + |
||
136 | +static void free_phys(void *ptr, unsigned long size) |
||
137 | +{ |
||
138 | + struct page *page; |
||
139 | + struct page *end; |
||
140 | + |
||
141 | + page = virt_to_page(ptr); |
||
142 | + end = page + (PAGE_ALIGN(size) >> PAGE_SHIFT); |
||
143 | + |
||
144 | + for (; page < end; ++page) |
||
145 | + __free_page(page); |
||
146 | +} |
||
147 | + |
||
148 | + |
||
149 | void *module_alloc(unsigned long size) |
||
150 | { |
||
151 | +#ifdef MODULE_START |
||
152 | return __vmalloc_node_range(size, 1, MODULE_START, MODULE_END, |
||
153 | GFP_KERNEL, PAGE_KERNEL, NUMA_NO_NODE, |
||
154 | __builtin_return_address(0)); |
||
155 | +#else |
||
156 | + void *ptr; |
||
157 | + |
||
158 | + if (size == 0) |
||
159 | + return NULL; |
||
160 | + |
||
161 | + ptr = alloc_phys(size); |
||
162 | + |
||
163 | + /* If we failed to allocate physically contiguous memory, |
||
164 | + * fall back to regular vmalloc. The module loader code will |
||
165 | + * create jump tables to handle long jumps */ |
||
166 | + if (!ptr) |
||
167 | + return vmalloc(size); |
||
168 | + |
||
169 | + return ptr; |
||
170 | +#endif |
||
171 | } |
||
172 | + |
||
173 | +static inline bool is_phys_addr(void *ptr) |
||
174 | +{ |
||
175 | +#ifdef CONFIG_64BIT |
||
176 | + return (KSEGX((unsigned long)ptr) == CKSEG0); |
||
177 | +#else |
||
178 | + return (KSEGX(ptr) == KSEG0); |
||
179 | #endif |
||
180 | +} |
||
181 | + |
||
182 | +/* Free memory returned from module_alloc */ |
||
183 | +void module_free(struct module *mod, void *module_region) |
||
184 | +{ |
||
185 | + if (is_phys_addr(module_region)) { |
||
186 | + if (mod->module_init == module_region) |
||
187 | + free_phys(module_region, mod->init_size); |
||
188 | + else if (mod->module_core == module_region) |
||
189 | + free_phys(module_region, mod->core_size); |
||
190 | + else |
||
191 | + BUG(); |
||
192 | + } else { |
||
193 | + vfree(module_region); |
||
194 | + } |
||
195 | +} |
||
196 | + |
||
197 | +static void *__module_alloc(int size, bool phys) |
||
198 | +{ |
||
199 | + void *ptr; |
||
200 | + |
||
201 | + if (phys) |
||
202 | + ptr = kmalloc(size, GFP_KERNEL); |
||
203 | + else |
||
204 | + ptr = vmalloc(size); |
||
205 | + return ptr; |
||
206 | +} |
||
207 | + |
||
208 | +static void __module_free(void *ptr) |
||
209 | +{ |
||
210 | + if (is_phys_addr(ptr)) |
||
211 | + kfree(ptr); |
||
212 | + else |
||
213 | + vfree(ptr); |
||
214 | +} |
||
215 | + |
||
216 | +int module_frob_arch_sections(Elf_Ehdr *hdr, Elf_Shdr *sechdrs, |
||
217 | + char *secstrings, struct module *mod) |
||
218 | +{ |
||
219 | + unsigned int symindex = 0; |
||
220 | + unsigned int core_size, init_size; |
||
221 | + int i; |
||
222 | + |
||
223 | + mod->arch.phys_plt_offset = 0; |
||
224 | + mod->arch.virt_plt_offset = 0; |
||
225 | + mod->arch.phys_plt_tbl = NULL; |
||
226 | + mod->arch.virt_plt_tbl = NULL; |
||
227 | + |
||
228 | + if (IS_ENABLED(CONFIG_64BIT)) |
||
229 | + return 0; |
||
230 | + |
||
231 | + for (i = 1; i < hdr->e_shnum; i++) |
||
232 | + if (sechdrs[i].sh_type == SHT_SYMTAB) |
||
233 | + symindex = i; |
||
234 | + |
||
235 | + core_size = get_plt_size(hdr, sechdrs, secstrings, symindex, false); |
||
236 | + init_size = get_plt_size(hdr, sechdrs, secstrings, symindex, true); |
||
237 | + |
||
238 | + if ((core_size + init_size) == 0) |
||
239 | + return 0; |
||
240 | + |
||
241 | + mod->arch.phys_plt_tbl = __module_alloc(core_size + init_size, 1); |
||
242 | + if (!mod->arch.phys_plt_tbl) |
||
243 | + return -ENOMEM; |
||
244 | + |
||
245 | + mod->arch.virt_plt_tbl = __module_alloc(core_size + init_size, 0); |
||
246 | + if (!mod->arch.virt_plt_tbl) { |
||
247 | + __module_free(mod->arch.phys_plt_tbl); |
||
248 | + mod->arch.phys_plt_tbl = NULL; |
||
249 | + return -ENOMEM; |
||
250 | + } |
||
251 | + |
||
252 | + return 0; |
||
253 | +} |
||
254 | |||
255 | int apply_r_mips_none(struct module *me, u32 *location, Elf_Addr v) |
||
256 | { |
||
257 | @@ -64,8 +272,39 @@ static int apply_r_mips_32_rel(struct mo |
||
258 | return 0; |
||
259 | } |
||
260 | |||
261 | +static Elf_Addr add_plt_entry_to(unsigned *plt_offset, |
||
262 | + void *start, Elf_Addr v) |
||
263 | +{ |
||
264 | + unsigned *tramp = start + *plt_offset; |
||
265 | + *plt_offset += 4 * sizeof(int); |
||
266 | + |
||
267 | + /* adjust carry for addiu */ |
||
268 | + if (v & 0x00008000) |
||
269 | + v += 0x10000; |
||
270 | + |
||
271 | + tramp[0] = 0x3c190000 | (v >> 16); /* lui t9, hi16 */ |
||
272 | + tramp[1] = 0x27390000 | (v & 0xffff); /* addiu t9, t9, lo16 */ |
||
273 | + tramp[2] = 0x03200008; /* jr t9 */ |
||
274 | + tramp[3] = 0x00000000; /* nop */ |
||
275 | + |
||
276 | + return (Elf_Addr) tramp; |
||
277 | +} |
||
278 | + |
||
279 | +static Elf_Addr add_plt_entry(struct module *me, void *location, Elf_Addr v) |
||
280 | +{ |
||
281 | + if (is_phys_addr(location)) |
||
282 | + return add_plt_entry_to(&me->arch.phys_plt_offset, |
||
283 | + me->arch.phys_plt_tbl, v); |
||
284 | + else |
||
285 | + return add_plt_entry_to(&me->arch.virt_plt_offset, |
||
286 | + me->arch.virt_plt_tbl, v); |
||
287 | + |
||
288 | +} |
||
289 | + |
||
290 | static int apply_r_mips_26_rel(struct module *me, u32 *location, Elf_Addr v) |
||
291 | { |
||
292 | + u32 ofs = *location & 0x03ffffff; |
||
293 | + |
||
294 | if (v % 4) { |
||
295 | pr_err("module %s: dangerous R_MIPS_26 REL relocation\n", |
||
296 | me->name); |
||
297 | @@ -73,14 +312,17 @@ static int apply_r_mips_26_rel(struct mo |
||
298 | } |
||
299 | |||
300 | if ((v & 0xf0000000) != (((unsigned long)location + 4) & 0xf0000000)) { |
||
301 | - printk(KERN_ERR |
||
302 | - "module %s: relocation overflow\n", |
||
303 | - me->name); |
||
304 | - return -ENOEXEC; |
||
305 | + v = add_plt_entry(me, location, v + (ofs << 2)); |
||
306 | + if (!v) { |
||
307 | + printk(KERN_ERR |
||
308 | + "module %s: relocation overflow\n", me->name); |
||
309 | + return -ENOEXEC; |
||
310 | + } |
||
311 | + ofs = 0; |
||
312 | } |
||
313 | |||
314 | *location = (*location & ~0x03ffffff) | |
||
315 | - ((*location + (v >> 2)) & 0x03ffffff); |
||
316 | + ((ofs + (v >> 2)) & 0x03ffffff); |
||
317 | |||
318 | return 0; |
||
319 | } |
||
320 | @@ -287,9 +529,36 @@ int module_finalize(const Elf_Ehdr *hdr, |
||
321 | list_add(&me->arch.dbe_list, &dbe_list); |
||
322 | spin_unlock_irq(&dbe_lock); |
||
323 | } |
||
324 | + |
||
325 | + /* Get rid of the fixup trampoline if we're running the module |
||
326 | + * from physically mapped address space */ |
||
327 | + if (me->arch.phys_plt_offset == 0) { |
||
328 | + __module_free(me->arch.phys_plt_tbl); |
||
329 | + me->arch.phys_plt_tbl = NULL; |
||
330 | + } |
||
331 | + if (me->arch.virt_plt_offset == 0) { |
||
332 | + __module_free(me->arch.virt_plt_tbl); |
||
333 | + me->arch.virt_plt_tbl = NULL; |
||
334 | + } |
||
335 | + |
||
336 | return 0; |
||
337 | } |
||
338 | |||
339 | +void module_arch_freeing_init(struct module *mod) |
||
340 | +{ |
||
341 | + if (mod->state == MODULE_STATE_LIVE) |
||
342 | + return; |
||
343 | + |
||
344 | + if (mod->arch.phys_plt_tbl) { |
||
345 | + __module_free(mod->arch.phys_plt_tbl); |
||
346 | + mod->arch.phys_plt_tbl = NULL; |
||
347 | + } |
||
348 | + if (mod->arch.virt_plt_tbl) { |
||
349 | + __module_free(mod->arch.virt_plt_tbl); |
||
350 | + mod->arch.virt_plt_tbl = NULL; |
||
351 | + } |
||
352 | +} |
||
353 | + |
||
354 | void module_arch_cleanup(struct module *mod) |
||
355 | { |
||
356 | spin_lock_irq(&dbe_lock); |