1 /*
2 * This file is subject to the terms and conditions of the GNU General Public
3 * License. See the file "COPYING" in the main directory of this archive
4 * for more details.
5 *
6 * Support for Kernel relocation at boot time
7 *
8 * Copyright (C) 2015, Imagination Technologies Ltd.
9 * Authors: Matt Redfearn (matt.redfearn@mips.com)
10 */
11 #include <asm/bootinfo.h>
12 #include <asm/cacheflush.h>
13 #include <asm/fw/fw.h>
14 #include <asm/sections.h>
15 #include <asm/setup.h>
16 #include <asm/timex.h>
17 #include <linux/elf.h>
18 #include <linux/kernel.h>
19 #include <linux/libfdt.h>
20 #include <linux/of_fdt.h>
21 #include <linux/sched/task.h>
22 #include <linux/start_kernel.h>
23 #include <linux/string.h>
24 #include <linux/printk.h>
25
26 #define RELOCATED(x) ((void *)((long)x + offset))
27
28 extern u32 _relocation_start[]; /* End kernel image / start relocation table */
29 extern u32 _relocation_end[]; /* End relocation table */
30
31 extern long __start___ex_table; /* Start exception table */
32 extern long __stop___ex_table; /* End exception table */
33
34 extern void __weak plat_fdt_relocated(void *new_location);
35
36 /*
37 * This function may be defined for a platform to perform any post-relocation
38 * fixup necessary.
39 * Return non-zero to abort relocation
40 */
plat_post_relocation(long offset)41 int __weak plat_post_relocation(long offset)
42 {
43 return 0;
44 }
45
get_synci_step(void)46 static inline u32 __init get_synci_step(void)
47 {
48 u32 res;
49
50 __asm__("rdhwr %0, $1" : "=r" (res));
51
52 return res;
53 }
54
sync_icache(void * kbase,unsigned long kernel_length)55 static void __init sync_icache(void *kbase, unsigned long kernel_length)
56 {
57 void *kend = kbase + kernel_length;
58 u32 step = get_synci_step();
59
60 do {
61 __asm__ __volatile__(
62 "synci 0(%0)"
63 : /* no output */
64 : "r" (kbase));
65
66 kbase += step;
67 } while (kbase < kend);
68
69 /* Completion barrier */
70 __sync();
71 }
72
apply_r_mips_64_rel(u32 * loc_orig,u32 * loc_new,long offset)73 static int __init apply_r_mips_64_rel(u32 *loc_orig, u32 *loc_new, long offset)
74 {
75 *(u64 *)loc_new += offset;
76
77 return 0;
78 }
79
apply_r_mips_32_rel(u32 * loc_orig,u32 * loc_new,long offset)80 static int __init apply_r_mips_32_rel(u32 *loc_orig, u32 *loc_new, long offset)
81 {
82 *loc_new += offset;
83
84 return 0;
85 }
86
apply_r_mips_26_rel(u32 * loc_orig,u32 * loc_new,long offset)87 static int __init apply_r_mips_26_rel(u32 *loc_orig, u32 *loc_new, long offset)
88 {
89 unsigned long target_addr = (*loc_orig) & 0x03ffffff;
90
91 if (offset % 4) {
92 pr_err("Dangerous R_MIPS_26 REL relocation\n");
93 return -ENOEXEC;
94 }
95
96 /* Original target address */
97 target_addr <<= 2;
98 target_addr += (unsigned long)loc_orig & ~0x03ffffff;
99
100 /* Get the new target address */
101 target_addr += offset;
102
103 if ((target_addr & 0xf0000000) != ((unsigned long)loc_new & 0xf0000000)) {
104 pr_err("R_MIPS_26 REL relocation overflow\n");
105 return -ENOEXEC;
106 }
107
108 target_addr -= (unsigned long)loc_new & ~0x03ffffff;
109 target_addr >>= 2;
110
111 *loc_new = (*loc_new & ~0x03ffffff) | (target_addr & 0x03ffffff);
112
113 return 0;
114 }
115
116
apply_r_mips_hi16_rel(u32 * loc_orig,u32 * loc_new,long offset)117 static int __init apply_r_mips_hi16_rel(u32 *loc_orig, u32 *loc_new, long offset)
118 {
119 unsigned long insn = *loc_orig;
120 unsigned long target = (insn & 0xffff) << 16; /* high 16bits of target */
121
122 target += offset;
123
124 *loc_new = (insn & ~0xffff) | ((target >> 16) & 0xffff);
125 return 0;
126 }
127
128 static int (*reloc_handlers_rel[]) (u32 *, u32 *, long) __initdata = {
129 [R_MIPS_64] = apply_r_mips_64_rel,
130 [R_MIPS_32] = apply_r_mips_32_rel,
131 [R_MIPS_26] = apply_r_mips_26_rel,
132 [R_MIPS_HI16] = apply_r_mips_hi16_rel,
133 };
134
do_relocations(void * kbase_old,void * kbase_new,long offset)135 int __init do_relocations(void *kbase_old, void *kbase_new, long offset)
136 {
137 u32 *r;
138 u32 *loc_orig;
139 u32 *loc_new;
140 int type;
141 int res;
142
143 for (r = _relocation_start; r < _relocation_end; r++) {
144 /* Sentinel for last relocation */
145 if (*r == 0)
146 break;
147
148 type = (*r >> 24) & 0xff;
149 loc_orig = kbase_old + ((*r & 0x00ffffff) << 2);
150 loc_new = RELOCATED(loc_orig);
151
152 if (reloc_handlers_rel[type] == NULL) {
153 /* Unsupported relocation */
154 pr_err("Unhandled relocation type %d at 0x%pK\n",
155 type, loc_orig);
156 return -ENOEXEC;
157 }
158
159 res = reloc_handlers_rel[type](loc_orig, loc_new, offset);
160 if (res)
161 return res;
162 }
163
164 return 0;
165 }
166
167 /*
168 * The exception table is filled in by the relocs tool after vmlinux is linked.
169 * It must be relocated separately since there will not be any relocation
170 * information for it filled in by the linker.
171 */
relocate_exception_table(long offset)172 static int __init relocate_exception_table(long offset)
173 {
174 unsigned long *etable_start, *etable_end, *e;
175
176 etable_start = RELOCATED(&__start___ex_table);
177 etable_end = RELOCATED(&__stop___ex_table);
178
179 for (e = etable_start; e < etable_end; e++)
180 *e += offset;
181
182 return 0;
183 }
184
185 #ifdef CONFIG_RANDOMIZE_BASE
186
rotate_xor(unsigned long hash,const void * area,size_t size)187 static inline __init unsigned long rotate_xor(unsigned long hash,
188 const void *area, size_t size)
189 {
190 const typeof(hash) *ptr = PTR_ALIGN(area, sizeof(hash));
191 size_t diff, i;
192
193 diff = (void *)ptr - area;
194 if (unlikely(size < diff + sizeof(hash)))
195 return hash;
196
197 size = ALIGN_DOWN(size - diff, sizeof(hash));
198
199 for (i = 0; i < size / sizeof(hash); i++) {
200 /* Rotate by odd number of bits and XOR. */
201 hash = (hash << ((sizeof(hash) * 8) - 7)) | (hash >> 7);
202 hash ^= ptr[i];
203 }
204
205 return hash;
206 }
207
get_random_boot(void)208 static inline __init unsigned long get_random_boot(void)
209 {
210 unsigned long entropy = random_get_entropy();
211 unsigned long hash = 0;
212
213 /* Attempt to create a simple but unpredictable starting entropy. */
214 hash = rotate_xor(hash, linux_banner, strlen(linux_banner));
215
216 /* Add in any runtime entropy we can get */
217 hash = rotate_xor(hash, &entropy, sizeof(entropy));
218
219 #if defined(CONFIG_USE_OF)
220 /* Get any additional entropy passed in device tree */
221 if (initial_boot_params) {
222 int node, len;
223 u64 *prop;
224
225 node = fdt_path_offset(initial_boot_params, "/chosen");
226 if (node >= 0) {
227 prop = fdt_getprop_w(initial_boot_params, node,
228 "kaslr-seed", &len);
229 if (prop && (len == sizeof(u64)))
230 hash = rotate_xor(hash, prop, sizeof(*prop));
231 }
232 }
233 #endif /* CONFIG_USE_OF */
234
235 return hash;
236 }
237
kaslr_disabled(void)238 static inline __init bool kaslr_disabled(void)
239 {
240 char *str;
241
242 #if defined(CONFIG_CMDLINE_BOOL)
243 const char *builtin_cmdline = CONFIG_CMDLINE;
244
245 str = strstr(builtin_cmdline, "nokaslr");
246 if (str == builtin_cmdline ||
247 (str > builtin_cmdline && *(str - 1) == ' '))
248 return true;
249 #endif
250 str = strstr(arcs_cmdline, "nokaslr");
251 if (str == arcs_cmdline || (str > arcs_cmdline && *(str - 1) == ' '))
252 return true;
253
254 return false;
255 }
256
determine_relocation_address(void)257 static inline void __init *determine_relocation_address(void)
258 {
259 /* Choose a new address for the kernel */
260 unsigned long kernel_length;
261 void *dest = &_text;
262 unsigned long offset;
263
264 if (kaslr_disabled())
265 return dest;
266
267 kernel_length = (long)_end - (long)(&_text);
268
269 offset = get_random_boot() << 16;
270 offset &= (CONFIG_RANDOMIZE_BASE_MAX_OFFSET - 1);
271 if (offset < kernel_length)
272 offset += ALIGN(kernel_length, 0xffff);
273
274 return RELOCATED(dest);
275 }
276
277 #else
278
determine_relocation_address(void)279 static inline void __init *determine_relocation_address(void)
280 {
281 /*
282 * Choose a new address for the kernel
283 * For now we'll hard code the destination
284 */
285 return (void *)0xffffffff81000000;
286 }
287
288 #endif
289
relocation_addr_valid(void * loc_new)290 static inline int __init relocation_addr_valid(void *loc_new)
291 {
292 if ((unsigned long)loc_new & 0x0000ffff) {
293 /* Inappropriately aligned new location */
294 return 0;
295 }
296 if ((unsigned long)loc_new < (unsigned long)&_end) {
297 /* New location overlaps original kernel */
298 return 0;
299 }
300 return 1;
301 }
302
relocate_kernel(void)303 void *__init relocate_kernel(void)
304 {
305 void *loc_new;
306 unsigned long kernel_length;
307 unsigned long bss_length;
308 long offset = 0;
309 int res = 1;
310 /* Default to original kernel entry point */
311 void *kernel_entry = start_kernel;
312 void *fdt = NULL;
313
314 /* Get the command line */
315 fw_init_cmdline();
316 #if defined(CONFIG_USE_OF)
317 /* Deal with the device tree */
318 fdt = plat_get_fdt();
319 early_init_dt_scan(fdt);
320 if (boot_command_line[0]) {
321 /* Boot command line was passed in device tree */
322 strlcpy(arcs_cmdline, boot_command_line, COMMAND_LINE_SIZE);
323 }
324 #endif /* CONFIG_USE_OF */
325
326 kernel_length = (long)(&_relocation_start) - (long)(&_text);
327 bss_length = (long)&__bss_stop - (long)&__bss_start;
328
329 loc_new = determine_relocation_address();
330
331 /* Sanity check relocation address */
332 if (relocation_addr_valid(loc_new))
333 offset = (unsigned long)loc_new - (unsigned long)(&_text);
334
335 /* Reset the command line now so we don't end up with a duplicate */
336 arcs_cmdline[0] = '\0';
337
338 if (offset) {
339 void (*fdt_relocated_)(void *) = NULL;
340 #if defined(CONFIG_USE_OF)
341 unsigned long fdt_phys = virt_to_phys(fdt);
342
343 /*
344 * If built-in dtb is used then it will have been relocated
345 * during kernel _text relocation. If appended DTB is used
346 * then it will not be relocated, but it should remain
347 * intact in the original location. If dtb is loaded by
348 * the bootloader then it may need to be moved if it crosses
349 * the target memory area
350 */
351
352 if (fdt_phys >= virt_to_phys(RELOCATED(&_text)) &&
353 fdt_phys <= virt_to_phys(RELOCATED(&_end))) {
354 void *fdt_relocated =
355 RELOCATED(ALIGN((long)&_end, PAGE_SIZE));
356 memcpy(fdt_relocated, fdt, fdt_totalsize(fdt));
357 fdt = fdt_relocated;
358 fdt_relocated_ = RELOCATED(&plat_fdt_relocated);
359 }
360 #endif /* CONFIG_USE_OF */
361
362 /* Copy the kernel to it's new location */
363 memcpy(loc_new, &_text, kernel_length);
364
365 /* Perform relocations on the new kernel */
366 res = do_relocations(&_text, loc_new, offset);
367 if (res < 0)
368 goto out;
369
370 /* Sync the caches ready for execution of new kernel */
371 sync_icache(loc_new, kernel_length);
372
373 res = relocate_exception_table(offset);
374 if (res < 0)
375 goto out;
376
377 /*
378 * The original .bss has already been cleared, and
379 * some variables such as command line parameters
380 * stored to it so make a copy in the new location.
381 */
382 memcpy(RELOCATED(&__bss_start), &__bss_start, bss_length);
383
384 /*
385 * If fdt was stored outside of the kernel image and
386 * had to be moved then update platform's state data
387 * with the new fdt location
388 */
389 if (fdt_relocated_)
390 fdt_relocated_(fdt);
391
392 /*
393 * Last chance for the platform to abort relocation.
394 * This may also be used by the platform to perform any
395 * initialisation required now that the new kernel is
396 * resident in memory and ready to be executed.
397 */
398 if (plat_post_relocation(offset))
399 goto out;
400
401 /* The current thread is now within the relocated image */
402 __current_thread_info = RELOCATED(&init_thread_union);
403
404 /* Return the new kernel's entry point */
405 kernel_entry = RELOCATED(start_kernel);
406 }
407 out:
408 return kernel_entry;
409 }
410
411 /*
412 * Show relocation information on panic.
413 */
show_kernel_relocation(const char * level)414 void show_kernel_relocation(const char *level)
415 {
416 unsigned long offset;
417
418 offset = __pa_symbol(_text) - __pa_symbol(VMLINUX_LOAD_ADDRESS);
419
420 if (IS_ENABLED(CONFIG_RELOCATABLE) && offset > 0) {
421 printk(level);
422 pr_cont("Kernel relocated by 0x%pK\n", (void *)offset);
423 pr_cont(" .text @ 0x%pK\n", _text);
424 pr_cont(" .data @ 0x%pK\n", _sdata);
425 pr_cont(" .bss @ 0x%pK\n", __bss_start);
426 }
427 }
428
kernel_location_notifier_fn(struct notifier_block * self,unsigned long v,void * p)429 static int kernel_location_notifier_fn(struct notifier_block *self,
430 unsigned long v, void *p)
431 {
432 show_kernel_relocation(KERN_EMERG);
433 return NOTIFY_DONE;
434 }
435
436 static struct notifier_block kernel_location_notifier = {
437 .notifier_call = kernel_location_notifier_fn
438 };
439
register_kernel_offset_dumper(void)440 static int __init register_kernel_offset_dumper(void)
441 {
442 atomic_notifier_chain_register(&panic_notifier_list,
443 &kernel_location_notifier);
444 return 0;
445 }
446 __initcall(register_kernel_offset_dumper);
447