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